[][src]Trait combine::Parser

pub trait Parser<Input: Stream> {
    type Output;
    type PartialState: Default;
    pub fn parse(
        &mut self,
        input: Input
    ) -> Result<(Self::Output, Input), <Input as StreamOnce>::Error> { ... }
pub fn parse_with_state(
        &mut self,
        input: &mut Input,
        state: &mut Self::PartialState
    ) -> Result<Self::Output, <Input as StreamOnce>::Error> { ... }
pub fn parse_stream(
        &mut self,
        input: &mut Input
    ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> { ... }
pub fn parse_lazy(
        &mut self,
        input: &mut Input
    ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> { ... }
pub fn add_error(
        &mut self,
        _error: &mut Tracked<<Input as StreamOnce>::Error>
    ) { ... }
pub fn parse_stream_partial(
        &mut self,
        input: &mut Input,
        state: &mut Self::PartialState
    ) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> { ... }
pub fn by_ref(&mut self) -> &mut Self

Notable traits for &'_ mut W

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

    where
        Self: Sized
, { ... }
pub fn with<P2>(self, p: P2) -> With<Self, P2>
    where
        Self: Sized,
        P2: Parser<Input>
, { ... }
pub fn skip<P2>(self, p: P2) -> Skip<Self, P2>
    where
        Self: Sized,
        P2: Parser<Input>
, { ... }
pub fn and<P2>(self, p: P2) -> (Self, P2)
    where
        Self: Sized,
        P2: Parser<Input>
, { ... }
pub fn or<P2>(self, p: P2) -> Or<Self, P2>
    where
        Self: Sized,
        P2: Parser<Input, Output = Self::Output>
, { ... }
pub fn then<N, F>(self, f: F) -> Then<Self, F>
    where
        Self: Sized,
        F: FnMut(Self::Output) -> N,
        N: Parser<Input>
, { ... }
pub fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F>
    where
        Self: Sized,
        F: FnMut(&mut Self::Output) -> N,
        N: Parser<Input>
, { ... }
pub fn then_ref<N, F>(self, f: F) -> ThenRef<Self, F>
    where
        Self: Sized,
        F: FnMut(&Self::Output) -> N,
        N: Parser<Input>
, { ... }
pub fn map<F, B>(self, f: F) -> Map<Self, F>
    where
        Self: Sized,
        F: FnMut(Self::Output) -> B
, { ... }
pub fn map_input<F, B>(self, f: F) -> MapInput<Self, F>
    where
        Self: Sized,
        F: FnMut(Self::Output, &mut Input) -> B
, { ... }
pub fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F>
    where
        Self: Sized,
        F: FnMut(Self::Output) -> Result<B, <Input as StreamOnce>::Error>
, { ... }
pub fn message<S>(self, msg: S) -> Message<Self, S>
    where
        Self: Sized,
        S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>
, { ... }
pub fn expected<S>(self, msg: S) -> Expected<Self, S>
    where
        Self: Sized,
        S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>
, { ... }
pub fn silent(self) -> Silent<Self>
    where
        Self: Sized
, { ... }
pub fn and_then<F, O, E>(self, f: F) -> AndThen<Self, F>
    where
        Self: Parser<Input> + Sized,
        F: FnMut(Self::Output) -> Result<O, E>,
        E: Into<<Input::Error as ParseError<Input::Token, Input::Range, Input::Position>>::StreamError>
, { ... }
pub fn iter(
        self,
        input: &mut Input
    ) -> Iter<'_, Input, Self, Self::PartialState, FirstMode>

Notable traits for Iter<'a, Input, P, S, M>

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

    where
        Self: Parser<Input> + Sized
, { ... }
pub fn partial_iter<'a, 's, M>(
        self,
        mode: M,
        input: &'a mut Input,
        partial_state: &'s mut Self::PartialState
    ) -> Iter<'a, Input, Self, &'s mut Self::PartialState, M>

Notable traits for Iter<'a, Input, P, S, M>

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

    where
        Self: Parser<Input> + Sized,
        M: ParseMode
, { ... }
pub fn boxed<'a>(
        self
    ) -> Box<dyn Parser<Input, Output = Self::Output, PartialState = Self::PartialState> + 'a>

Notable traits for Box<W, Global>

impl<W> Write for Box<W, Global> where
    W: Write + ?Sized
impl<R> Read for Box<R, Global> where
    R: Read + ?Sized
impl<F, A> Future for Box<F, A> where
    F: Unpin + Future + ?Sized,
    A: Allocator + 'static, 
type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
    I: Iterator + ?Sized,
    A: Allocator
type Item = <I as Iterator>::Item;

    where
        Self: Sized + 'a
, { ... }
pub fn left<R>(self) -> Either<Self, R>
    where
        Self: Sized,
        R: Parser<Input, Output = Self::Output>
, { ... }
pub fn right<L>(self) -> Either<L, Self>
    where
        Self: Sized,
        L: Parser<Input, Output = Self::Output>
, { ... }
pub fn spanned(self) -> Spanned<Self>
    where
        Self: Sized
, { ... } }

By implementing the Parser trait a type says that it can be used to parse an input stream into the type Output.

All methods have a default implementation but there needs to be at least an implementation of parse_stream, parse_stream, or parse_lazy. If the last is implemented, an implementation of add_error may also be required. See the documentation for parse_lazy for details.

Associated Types

type Output[src]

The type which is returned if the parser is successful.

type PartialState: Default[src]

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

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

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.

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

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.

pub fn parse_stream(
    &mut self,
    input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]

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

Semantically equivalent to parse_stream, except this method returns a flattened result type, combining Result and Commit into a single ParseResult.

pub fn parse_lazy(
    &mut self,
    input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]

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

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

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

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

pub fn add_error(&mut self, _error: &mut Tracked<<Input as StreamOnce>::Error>)[src]

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

See parse_lazy for details.

pub fn parse_stream_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]

Like parse_stream but supports partial parsing.

pub fn by_ref(&mut self) -> &mut Self

Notable traits for &'_ mut W

impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized
impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized
impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized
type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized
type Item = <I as Iterator>::Item;
where
    Self: Sized
[src]

Borrows a parser instead of consuming it.

Used to apply parser combinators on self without losing ownership.

fn test(input: &mut &'static str) -> StdParseResult<(char, char), &'static str> {
    let mut p = digit();
    let ((d, _), committed) = (p.by_ref(), letter()).parse_stream(input).into_result()?;
    let (d2, committed) = committed.combine(|_| p.parse_stream(input).into_result())?;
    Ok(((d, d2), committed))
}

fn main() {
    let mut input = "1a23";
    assert_eq!(
        test(&mut input).map(|(t, c)| (t, c.map(|_| input))),
        Ok((('1', '2'), Commit::Commit("3")))
    );
}

pub fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input>, 
[src]

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

pub fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input>, 
[src]

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

pub fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input>, 
[src]

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

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

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

If you are looking to chain 3 or more parsers using or you may consider using the choice! macro instead, which can be clearer and may result in a faster parser.

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

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

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

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

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 then_partial 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, "")));

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

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, "")));

pub fn then_ref<N, F>(self, f: F) -> ThenRef<Self, F> where
    Self: Sized,
    F: FnMut(&Self::Output) -> N,
    N: Parser<Input>, 
[src]

Parses using self and then passes a reference to the value to f which returns a parser used to parse the rest of the input. The value is then combined with the output of f.

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_ref(|d| {
        if *d == '9' {
            digit().left()
        }
        else {
            unexpected_any(*d).message("Not a nine").right()
        }
    })
    .easy_parse("98");
assert_eq!(result, Ok((('9', '8'), "")));

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

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

pub fn map_input<F, B>(self, f: F) -> MapInput<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output, &mut Input) -> B, 
[src]

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

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

pub fn message<S>(self, msg: S) -> Message<Self, S> where
    Self: Sized,
    S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>, 
[src]

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

let result = token('9')
    .message("Not a nine")
    .easy_parse(position::Stream::new("8"));
assert_eq!(result, Err(easy::Errors {
    position: SourcePosition::default(),
    errors: vec![
        easy::Error::Unexpected('8'.into()),
        easy::Error::Expected('9'.into()),
        easy::Error::Message("Not a nine".into())
    ]
}));

pub fn expected<S>(self, msg: S) -> Expected<Self, S> where
    Self: Sized,
    S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>, 
[src]

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

let result = token('9')
    .expected("nine")
    .easy_parse(position::Stream::new("8"));
assert_eq!(result, Err(easy::Errors {
    position: SourcePosition::default(),
    errors: vec![
        easy::Error::Unexpected('8'.into()),
        easy::Error::Expected("nine".into())
    ]
}));

let result = token('9')
    .expected(error::Format(format_args!("That is not a nine!")))
    .easy_parse(position::Stream::new("8"));
assert_eq!(result, Err(easy::Errors {
    position: SourcePosition::default(),
    errors: vec![
        easy::Error::Unexpected('8'.into()),
        easy::Error::Expected("That is not a nine!".to_string().into())
    ]
}));

pub fn silent(self) -> Silent<Self> where
    Self: Sized
[src]

Parses with self, if it fails without consuming any input any expected errors that would otherwise be emitted by self are suppressed.

let result = token('9')
    .expected("nine")
    .silent()
    .easy_parse(position::Stream::new("8"));
assert_eq!(result, Err(easy::Errors {
    position: SourcePosition::default(),
    errors: vec![
        easy::Error::Unexpected('8'.into()),
    ]
}));

pub fn and_then<F, O, E>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    E: Into<<Input::Error as ParseError<Input::Token, Input::Range, Input::Position>>::StreamError>, 
[src]

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

let mut parser = many1(digit())
    .and_then(|s: String| s.parse::<i32>());
let result = parser.easy_parse(position::Stream::new("1234")).map(|(x, state)| (x, state.input));
assert_eq!(result, Ok((1234, "")));
let result = parser.easy_parse(position::Stream::new("999999999999999999999999"));
assert!(result.is_err());
// Errors are report as if they occurred at the start of the parse
assert_eq!(result.unwrap_err().position, SourcePosition { line: 1, column: 1 });

pub fn iter(
    self,
    input: &mut Input
) -> Iter<'_, Input, Self, Self::PartialState, FirstMode>

Notable traits for Iter<'a, Input, P, S, M>

impl<'a, Input, P, S, M> Iterator for Iter<'a, Input, P, S, M> where
    Input: Stream,
    P: Parser<Input>,
    S: BorrowMut<P::PartialState>,
    M: ParseMode, 
type Item = P::Output;
where
    Self: Parser<Input> + Sized
[src]

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

pub fn partial_iter<'a, 's, M>(
    self,
    mode: M,
    input: &'a mut Input,
    partial_state: &'s mut Self::PartialState
) -> Iter<'a, Input, Self, &'s mut Self::PartialState, M>

Notable traits for Iter<'a, Input, P, S, M>

impl<'a, Input, P, S, M> Iterator for Iter<'a, Input, P, S, M> where
    Input: Stream,
    P: Parser<Input>,
    S: BorrowMut<P::PartialState>,
    M: ParseMode, 
type Item = P::Output;
where
    Self: Parser<Input> + Sized,
    M: ParseMode, 
[src]

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

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

Notable traits for Box<W, Global>

impl<W> Write for Box<W, Global> where
    W: Write + ?Sized
impl<R> Read for Box<R, Global> where
    R: Read + ?Sized
impl<F, A> Future for Box<F, A> where
    F: Unpin + Future + ?Sized,
    A: Allocator + 'static, 
type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
    I: Iterator + ?Sized,
    A: Allocator
type Item = <I as Iterator>::Item;
where
    Self: Sized + 'a, 
[src]

This is supported on crate feature std only.

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

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

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

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

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

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

pub fn spanned(self) -> Spanned<Self> where
    Self: Sized
[src]

Marks errors produced inside the self parser with the span from the start of the parse to the end of it.

use combine::{*, parser::{char::string, combinator::spanned}};
use combine::stream::{easy, span};

let input = "hel";
let result = spanned(string("hello")).parse(
    span::Stream::<_, easy::Errors<_, _, span::Span<_>>>::from(easy::Stream::from(input)),
);
assert!(result.is_err());
assert_eq!(
    result.unwrap_err().position.map(|p| p.translate_position(input)),
    span::Span { start: 0, end: 3 },
);
Loading content...

Implementations on Foreign Types

impl<'a, Input: Stream, O> Parser<Input> for dyn FnMut(&mut Input) -> StdParseResult<O, Input> + 'a[src]

type Output = O

type PartialState = ()

impl<Input, O> Parser<Input> for fn(_: &mut Input) -> StdParseResult<O, Input> where
    Input: Stream
[src]

type Output = O

type PartialState = ()

impl<Input: Stream, A> Parser<Input> for (A,) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>, 
[src]

type Output = (A::Output,)

type PartialState = PartialState1<SequenceState<A::Output, A::PartialState>>

impl<Input: Stream, A, B> Parser<Input> for (A, B) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>, 
[src]

type Output = (A::Output, B::Output)

type PartialState = PartialState2<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>>

impl<Input: Stream, A, B, C> Parser<Input> for (A, B, C) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>, 
[src]

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

impl<Input: Stream, A, B, C, D> Parser<Input> for (A, B, C, D) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>, 
[src]

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

impl<Input: Stream, A, B, C, D, E> Parser<Input> for (A, B, C, D, E) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>,
    E: Parser<Input>, 
[src]

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

impl<Input: Stream, A, B, C, D, E, F> Parser<Input> for (A, B, C, D, E, F) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>,
    E: Parser<Input>,
    F: Parser<Input>, 
[src]

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

impl<Input: Stream, A, B, C, D, E, F, G> Parser<Input> for (A, B, C, D, E, F, G) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>,
    E: Parser<Input>,
    F: Parser<Input>,
    G: Parser<Input>, 
[src]

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

impl<Input: Stream, A, B, C, D, E, F, G, H> Parser<Input> for (A, B, C, D, E, F, G, H) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>,
    E: Parser<Input>,
    F: Parser<Input>,
    G: Parser<Input>,
    H: Parser<Input>, 
[src]

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

impl<Input: Stream, A, B, C, D, E, F, G, H, I> Parser<Input> for (A, B, C, D, E, F, G, H, I) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>,
    E: Parser<Input>,
    F: Parser<Input>,
    G: Parser<Input>,
    H: Parser<Input>,
    I: Parser<Input>, 
[src]

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

impl<Input: Stream, A, B, C, D, E, F, G, H, I, J> Parser<Input> for (A, B, C, D, E, F, G, H, I, J) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>,
    E: Parser<Input>,
    F: Parser<Input>,
    G: Parser<Input>,
    H: Parser<Input>,
    I: Parser<Input>,
    J: Parser<Input>, 
[src]

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

impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>,
    E: Parser<Input>,
    F: Parser<Input>,
    G: Parser<Input>,
    H: Parser<Input>,
    I: Parser<Input>,
    J: Parser<Input>,
    K: Parser<Input>, 
[src]

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

impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>,
    E: Parser<Input>,
    F: Parser<Input>,
    G: Parser<Input>,
    H: Parser<Input>,
    I: Parser<Input>,
    J: Parser<Input>,
    K: Parser<Input>,
    L: Parser<Input>, 
[src]

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

impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L, M> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>,
    E: Parser<Input>,
    F: Parser<Input>,
    G: Parser<Input>,
    H: Parser<Input>,
    I: Parser<Input>,
    J: Parser<Input>,
    K: Parser<Input>,
    L: Parser<Input>,
    M: Parser<Input>, 
[src]

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output)

type PartialState = PartialState13<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>, SequenceState<M::Output, M::PartialState>>

impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>,
    E: Parser<Input>,
    F: Parser<Input>,
    G: Parser<Input>,
    H: Parser<Input>,
    I: Parser<Input>,
    J: Parser<Input>,
    K: Parser<Input>,
    L: Parser<Input>,
    M: Parser<Input>,
    N: Parser<Input>, 
[src]

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output)

type PartialState = PartialState14<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>, SequenceState<M::Output, M::PartialState>, SequenceState<N::Output, N::PartialState>>

impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L, M, N, P> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, P) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>,
    E: Parser<Input>,
    F: Parser<Input>,
    G: Parser<Input>,
    H: Parser<Input>,
    I: Parser<Input>,
    J: Parser<Input>,
    K: Parser<Input>,
    L: Parser<Input>,
    M: Parser<Input>,
    N: Parser<Input>,
    P: Parser<Input>, 
[src]

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, P::Output)

type PartialState = PartialState15<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>, SequenceState<M::Output, M::PartialState>, SequenceState<N::Output, N::PartialState>, SequenceState<P::Output, P::PartialState>>

impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>,
    E: Parser<Input>,
    F: Parser<Input>,
    G: Parser<Input>,
    H: Parser<Input>,
    I: Parser<Input>,
    J: Parser<Input>,
    K: Parser<Input>,
    L: Parser<Input>,
    M: Parser<Input>,
    N: Parser<Input>,
    P: Parser<Input>,
    Q: Parser<Input>, 
[src]

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, P::Output, Q::Output)

type PartialState = PartialState16<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>, SequenceState<M::Output, M::PartialState>, SequenceState<N::Output, N::PartialState>, SequenceState<P::Output, P::PartialState>, SequenceState<Q::Output, Q::PartialState>>

impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q, R> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q, R) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>,
    E: Parser<Input>,
    F: Parser<Input>,
    G: Parser<Input>,
    H: Parser<Input>,
    I: Parser<Input>,
    J: Parser<Input>,
    K: Parser<Input>,
    L: Parser<Input>,
    M: Parser<Input>,
    N: Parser<Input>,
    P: Parser<Input>,
    Q: Parser<Input>,
    R: Parser<Input>, 
[src]

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, P::Output, Q::Output, R::Output)

type PartialState = PartialState17<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>, SequenceState<M::Output, M::PartialState>, SequenceState<N::Output, N::PartialState>, SequenceState<P::Output, P::PartialState>, SequenceState<Q::Output, Q::PartialState>, SequenceState<R::Output, R::PartialState>>

impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q, R, S> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q, R, S) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>,
    E: Parser<Input>,
    F: Parser<Input>,
    G: Parser<Input>,
    H: Parser<Input>,
    I: Parser<Input>,
    J: Parser<Input>,
    K: Parser<Input>,
    L: Parser<Input>,
    M: Parser<Input>,
    N: Parser<Input>,
    P: Parser<Input>,
    Q: Parser<Input>,
    R: Parser<Input>,
    S: Parser<Input>, 
[src]

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, P::Output, Q::Output, R::Output, S::Output)

type PartialState = PartialState18<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>, SequenceState<M::Output, M::PartialState>, SequenceState<N::Output, N::PartialState>, SequenceState<P::Output, P::PartialState>, SequenceState<Q::Output, Q::PartialState>, SequenceState<R::Output, R::PartialState>, SequenceState<S::Output, S::PartialState>>

impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q, R, S, T> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q, R, S, T) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>,
    E: Parser<Input>,
    F: Parser<Input>,
    G: Parser<Input>,
    H: Parser<Input>,
    I: Parser<Input>,
    J: Parser<Input>,
    K: Parser<Input>,
    L: Parser<Input>,
    M: Parser<Input>,
    N: Parser<Input>,
    P: Parser<Input>,
    Q: Parser<Input>,
    R: Parser<Input>,
    S: Parser<Input>,
    T: Parser<Input>, 
[src]

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, P::Output, Q::Output, R::Output, S::Output, T::Output)

type PartialState = PartialState19<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>, SequenceState<M::Output, M::PartialState>, SequenceState<N::Output, N::PartialState>, SequenceState<P::Output, P::PartialState>, SequenceState<Q::Output, Q::PartialState>, SequenceState<R::Output, R::PartialState>, SequenceState<S::Output, S::PartialState>, SequenceState<T::Output, T::PartialState>>

impl<Input: Stream, A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q, R, S, T, U> Parser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q, R, S, T, U) where
    Input: Stream,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
    A: Parser<Input>,
    B: Parser<Input>,
    C: Parser<Input>,
    D: Parser<Input>,
    E: Parser<Input>,
    F: Parser<Input>,
    G: Parser<Input>,
    H: Parser<Input>,
    I: Parser<Input>,
    J: Parser<Input>,
    K: Parser<Input>,
    L: Parser<Input>,
    M: Parser<Input>,
    N: Parser<Input>,
    P: Parser<Input>,
    Q: Parser<Input>,
    R: Parser<Input>,
    S: Parser<Input>,
    T: Parser<Input>,
    U: Parser<Input>, 
[src]

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, P::Output, Q::Output, R::Output, S::Output, T::Output, U::Output)

type PartialState = PartialState20<SequenceState<A::Output, A::PartialState>, SequenceState<B::Output, B::PartialState>, SequenceState<C::Output, C::PartialState>, SequenceState<D::Output, D::PartialState>, SequenceState<E::Output, E::PartialState>, SequenceState<F::Output, F::PartialState>, SequenceState<G::Output, G::PartialState>, SequenceState<H::Output, H::PartialState>, SequenceState<I::Output, I::PartialState>, SequenceState<J::Output, J::PartialState>, SequenceState<K::Output, K::PartialState>, SequenceState<L::Output, L::PartialState>, SequenceState<M::Output, M::PartialState>, SequenceState<N::Output, N::PartialState>, SequenceState<P::Output, P::PartialState>, SequenceState<Q::Output, Q::PartialState>, SequenceState<R::Output, R::PartialState>, SequenceState<S::Output, S::PartialState>, SequenceState<T::Output, T::PartialState>, SequenceState<U::Output, U::PartialState>>

impl<'a, P: ?Sized, Input> Parser<Input> for &'a mut P where
    P: Parser<Input>,
    Input: Stream
[src]

type Output = P::Output

type PartialState = P::PartialState

impl<P: ?Sized, Input> Parser<Input> for Box<P> where
    P: Parser<Input>,
    Input: Stream
[src]

type Output = P::Output

type PartialState = P::PartialState

Loading content...

Implementors

impl<'a, Input, F, G, R> Parser<Input> for CapturesMany<F, G, R, Input> where
    F: FromIterator<Input::Range>,
    G: FromIterator<F>,
    R: Regex<Input::Range>,
    Input: RangeStream,
    Input::Range: Range
[src]

This is supported on crate feature regex only.

type Output = G

type PartialState = ()

impl<'a, Input, F, R> Parser<Input> for Captures<F, R, Input> where
    F: FromIterator<Input::Range>,
    R: Regex<Input::Range>,
    Input: RangeStream,
    Input::Range: Range
[src]

This is supported on crate feature regex only.

type Output = F

type PartialState = ()

impl<'a, Input, F, R> Parser<Input> for FindMany<F, R, Input> where
    F: FromIterator<Input::Range>,
    R: Regex<Input::Range>,
    Input: RangeStream,
    Input::Range: Range
[src]

This is supported on crate feature regex only.

type Output = F

type PartialState = ()

impl<'a, Input, R> Parser<Input> for Find<R, Input> where
    R: Regex<Input::Range>,
    Input: RangeStream,
    Input::Range: Range
[src]

This is supported on crate feature regex only.

type Output = Input::Range

type PartialState = ()

impl<'a, Input, R> Parser<Input> for Match<R, Input> where
    R: Regex<Input::Range>,
    Input: RangeStream
[src]

This is supported on crate feature regex only.

type Output = Input::Range

type PartialState = ()

impl<'s, 'a, P, Q, I, J, F> Parser<I> for Iterate<F, J, P> where
    P: FnMut(&J::Item, &mut I) -> Q,
    Q: Parser<I>,
    I: Stream,
    J: IntoIterator + Clone,
    F: Extend<Q::Output> + Default
[src]

type Output = F

type PartialState = (Option<(J::IntoIter, Option<J::Item>)>, bool, F, Q::PartialState)

impl<F, Input, P> Parser<Input> for Count<F, Input, P> where
    <Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
    Input: Stream,
    Input: Stream,
    P: Parser<Input>,
    F: Extend<P::Output> + Default
[src]

type Output = F

type PartialState = ()

impl<F, Input, P> Parser<Input> for Many1<F, P> where
    Input: Stream,
    F: Extend<P::Output> + Default,
    P: Parser<Input>, 
[src]

type Output = F

type PartialState = (bool, bool, F, P::PartialState)

impl<F, Input, P> Parser<Input> for Many<F, P> where
    Input: Stream,
    P: Parser<Input>,
    F: Extend<P::Output> + Default
[src]

type Output = F

type PartialState = (F, P::PartialState)

impl<F, Input, P> Parser<Input> for TakeUntil<F, P> where
    Input: Stream,
    F: Extend<<Input as StreamOnce>::Token> + Default,
    P: Parser<Input>, 
[src]

type Output = F

type PartialState = (F, P::PartialState)

impl<F, Input, P, E> Parser<Input> for RepeatUntil<F, P, E> where
    Input: Stream,
    F: Extend<P::Output> + Default,
    P: Parser<Input>,
    E: Parser<Input>, 
[src]

type Output = F

type PartialState = (F, bool, P::PartialState, E::PartialState)

impl<F, Input, P, S> Parser<Input> for SepBy1<F, P, S> where
    Input: Stream,
    F: Extend<P::Output> + Default,
    P: Parser<Input>,
    S: Parser<Input>, 
[src]

type Output = F

type PartialState = (Option<Commit<()>>, F, <With<S, P> as Parser<Input>>::PartialState)

impl<F, Input, P, S> Parser<Input> for SepBy<F, P, S> where
    Input: Stream,
    F: Extend<P::Output> + Default,
    P: Parser<Input>,
    S: Parser<Input>, 
[src]

type Output = F

type PartialState = <Or<SepBy1<F, P, S>, FnParser<Input, fn(_: &mut Input) -> StdParseResult<F, Input>>> as Parser<Input>>::PartialState

impl<F, Input, P, S> Parser<Input> for SepEndBy1<F, P, S> where
    Input: Stream,
    F: Extend<P::Output> + Default,
    P: Parser<Input>,
    S: Parser<Input>, 
[src]

type Output = F

type PartialState = (Option<Commit<()>>, F, <With<S, Optional<P>> as Parser<Input>>::PartialState)

impl<F, Input, P, S> Parser<Input> for SepEndBy<F, P, S> where
    Input: Stream,
    F: Extend<P::Output> + Default,
    P: Parser<Input>,
    S: Parser<Input>, 
[src]

type Output = F

type PartialState = <Or<SepEndBy1<F, P, S>, FnParser<Input, fn(_: &mut Input) -> StdParseResult<F, Input>>> as Parser<Input>>::PartialState

impl<Input> Parser<Input> for TakeUntilByte2<Input> where
    <Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
    Input: Stream,
    Input: RangeStream,
    Input::Range: AsRef<[u8]> + Range
[src]

type Output = Input::Range

type PartialState = ()

impl<Input> Parser<Input> for TakeUntilByte3<Input> where
    <Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
    Input: Stream,
    Input: RangeStream,
    Input::Range: AsRef<[u8]> + Range
[src]

type Output = Input::Range

type PartialState = ()

impl<Input> Parser<Input> for TakeUntilByte<Input> where
    <Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
    Input: Stream,
    Input: RangeStream,
    Input::Range: AsRef<[u8]> + Range
[src]

type Output = Input::Range

type PartialState = ()

impl<Input> Parser<Input> for Digit<Input> where
    <Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
    Input: Stream,
    Input: Stream<Token = char>, 
[src]

type Output = char

type PartialState = ()

impl<Input> Parser<Input> for Range<Input> where
    Input: RangeStream,
    Input::Range: PartialEq + Range
[src]

type Output = Input::Range

type PartialState = ()

impl<Input> Parser<Input> for Take<Input> where
    Input: RangeStream
[src]

type Output = Input::Range

type PartialState = ()

impl<Input> Parser<Input> for TakeUntilRange<Input> where
    Input: RangeStream,
    Input::Range: PartialEq + Range
[src]

type Output = Input::Range

type PartialState = usize

impl<Input> Parser<Input> for Any<Input> where
    Input: Stream
[src]

type Output = Input::Token

type PartialState = ()

impl<Input> Parser<Input> for Eof<Input> where
    Input: Stream
[src]

type Output = ()

type PartialState = ()

impl<Input> Parser<Input> for Position<Input> where
    Input: Stream
[src]

type Output = Input::Position

type PartialState = ()

impl<Input> Parser<Input> for Token<Input> where
    Input: Stream,
    Input::Token: PartialEq + Clone
[src]

type Output = Input::Token

type PartialState = ()

impl<Input, A, B, P, F> Parser<Input> for FlatMap<P, F> where
    Input: Stream,
    P: Parser<Input, Output = A>,
    F: FnMut(A) -> Result<B, Input::Error>, 
[src]

type Output = B

type PartialState = P::PartialState

impl<Input, A, B, P, F> Parser<Input> for Map<P, F> where
    Input: Stream,
    P: Parser<Input, Output = A>,
    F: FnMut(A) -> B, 
[src]

type Output = B

type PartialState = P::PartialState

impl<Input, A, B, P, F> Parser<Input> for MapInput<P, F> where
    Input: Stream,
    P: Parser<Input, Output = A>,
    F: FnMut(A, &mut Input) -> B, 
[src]

type Output = B

type PartialState = P::PartialState

impl<Input, C, E, T> Parser<Input> for Tokens<C, E, T, Input> where
    C: FnMut(T::Item, Input::Token) -> bool,
    E: for<'s> ErrorInfo<'s, Input::Token, Input::Range>,
    T: Clone + IntoIterator,
    Input: Stream
[src]

type Output = T

type PartialState = ()

impl<Input, C, T> Parser<Input> for TokensCmp<C, T, Input> where
    C: FnMut(T::Item, Input::Token) -> bool,
    T: Clone + IntoIterator,
    Input: Stream
[src]

type Output = T

type PartialState = ()

impl<Input, E, O> Parser<Input> for EnvParser<E, Input, O> where
    E: Clone,
    Input: Stream
[src]

type Output = O

type PartialState = ()

impl<Input, F> Parser<Input> for TakeWhile1<Input, F> where
    Input: RangeStream,
    Input::Range: Range,
    F: FnMut(Input::Token) -> bool
[src]

type Output = Input::Range

type PartialState = usize

impl<Input, F> Parser<Input> for TakeWhile<Input, F> where
    Input: RangeStream,
    Input::Range: Range,
    F: FnMut(Input::Token) -> bool
[src]

type Output = Input::Range

type PartialState = usize

impl<Input, F, O, S> Parser<Input> for Opaque<F, Input, O, S> where
    Input: Stream,
    S: Default,
    F: FnMut(&mut dyn FnMut(&mut dyn Parser<Input, Output = O, PartialState = S>)), 
[src]

type Output = O

type PartialState = S

impl<Input, F, R> Parser<Input> for TakeFn<F, Input> where
    F: FnMut(Input::Range) -> R,
    R: Into<TakeRange>,
    Input: RangeStream,
    Input::Range: Range
[src]

type Output = Input::Range

type PartialState = usize

impl<Input, F, R> Parser<Input> for Produce<Input, F> where
    Input: Stream,
    F: FnMut() -> R, 
[src]

type Output = R

type PartialState = ()

impl<Input, InputInner, P, C> Parser<Input> for InputConverter<InputInner, P, C> where
    Input: Stream,
    InputInner: Stream,
    P: Parser<InputInner>,
    C: Converter<'c, Input, InputInner = InputInner>, 
[src]

type Output = P::Output

type PartialState = P::PartialState

impl<Input, L, R> Parser<Input> for Either<L, R> where
    Input: Stream,
    L: Parser<Input>,
    R: Parser<Input, Output = L::Output>, 
[src]

type Output = L::Output

type PartialState = Option<Either<L::PartialState, R::PartialState>>

impl<Input, L, R, P> Parser<Input> for Between<Input, L, R, P> where
    <Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
    Input: Stream,
    Input: Stream,
    L: Parser<Input>,
    R: Parser<Input>,
    P: Parser<Input>, 
[src]

type Output = P::Output

type PartialState = <Map<(L, P, R), fn(_: (L::Output, P::Output, R::Output)) -> P::Output> as Parser<Input>>::PartialState

impl<Input, O, F> Parser<Input> for FnParser<Input, F> where
    Input: Stream,
    F: FnMut(&mut Input) -> StdParseResult<O, Input>, 
[src]

type Output = O

type PartialState = ()

impl<Input, O, P1, P2> Parser<Input> for Or<P1, P2> where
    Input: Stream,
    P1: Parser<Input, Output = O>,
    P2: Parser<Input, Output = O>, 
[src]

type Output = O

type PartialState = <Choice<(P1, P2)> as Parser<Input>>::PartialState

impl<Input, O, P> Parser<Input> for FromStr<Input, O, P> where
    <Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
    Input: Stream,
    P: Parser<Input>,
    P::Output: StrLike,
    O: FromStr,
    O::Err: Display
[src]

type Output = O

type PartialState = P::PartialState

impl<Input, O, P> Parser<Input> for LookAhead<P> where
    Input: Stream,
    P: Parser<Input, Output = O>, 
[src]

type Output = O

type PartialState = ()

impl<Input, O, P> Parser<Input> for NotFollowedBy<P> where
    Input: Stream,
    P: Parser<Input, Output = O>, 
[src]

type Output = ()

type PartialState = P::PartialState

impl<Input, O, P> Parser<Input> for Try<P> where
    Input: Stream,
    P: Parser<Input, Output = O>, 
[src]

type Output = O

type PartialState = P::PartialState

impl<Input, O, P, R> Parser<Input> for Factory<P, R> where
    Input: Stream,
    P: FnMut(&mut Input) -> R,
    R: Parser<Input, Output = O>, 
[src]

type Output = O

type PartialState = R::PartialState

impl<Input, O, P, R> Parser<Input> for Lazy<P> where
    Input: Stream,
    P: FnMut() -> R,
    R: Parser<Input, Output = O>, 
[src]

type Output = O

type PartialState = R::PartialState

impl<Input, P1, P2> Parser<Input> for Skip<P1, P2> where
    Input: Stream,
    P1: Parser<Input>,
    P2: Parser<Input>, 
[src]

type Output = P1::Output

type PartialState = <(P1, Ignore<P2>) as Parser<Input>>::PartialState

impl<Input, P1, P2> Parser<Input> for With<P1, P2> where
    Input: Stream,
    P1: Parser<Input>,
    P2: Parser<Input>, 
[src]

type Output = P2::Output

type PartialState = <(Ignore<P1>, P2) as Parser<Input>>::PartialState

impl<Input, P> Parser<Input> for Choice<P> where
    Input: Stream,
    P: ChoiceParser<Input>, 
[src]

type Output = P::Output

type PartialState = P::PartialState

impl<Input, P> Parser<Input> for Optional<P> where
    Input: Stream,
    P: Parser<Input>, 
[src]

type Output = Option<P::Output>

type PartialState = P::PartialState

impl<Input, P> Parser<Input> for AnyPartialStateParser<P> where
    Input: Stream,
    P: Parser<Input>,
    P::PartialState: 'static, 
[src]

type Output = P::Output

type PartialState = AnyPartialState

impl<Input, P> Parser<Input> for AnySendPartialStateParser<P> where
    Input: Stream,
    P: Parser<Input>,
    P::PartialState: Send + 'static, 
[src]

type Output = P::Output

type PartialState = AnySendPartialState

impl<Input, P> Parser<Input> for AnySendSyncPartialStateParser<P> where
    Input: Stream,
    P: Parser<Input>,
    P::PartialState: Send + Sync + 'static, 
[src]

type Output = P::Output

type PartialState = AnySendSyncPartialState

impl<Input, P> Parser<Input> for Ignore<P> where
    Input: Stream,
    P: Parser<Input>, 
[src]

type Output = ()

type PartialState = P::PartialState

impl<Input, P> Parser<Input> for NoPartial<P> where
    Input: Stream,
    P: Parser<Input>, 
[src]

type Output = <P as Parser<Input>>::Output

type PartialState = ()

impl<Input, P> Parser<Input> for Silent<P> where
    P: Parser<Input>,
    Input: Stream
[src]

type Output = P::Output

type PartialState = P::PartialState

impl<Input, P> Parser<Input> for combine::parser::range::Recognize<Input, P> where
    <Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
    Input: Stream,
    P: Parser<Input>,
    Input: RangeStream,
    <Input as StreamOnce>::Range: Range
[src]

type Output = <Input as StreamOnce>::Range

type PartialState = <RecognizeWithValue<P> as Parser<Input>>::PartialState

impl<Input, P> Parser<Input> for RecognizeWithValue<P> where
    P: Parser<Input>,
    Input: RangeStream,
    <Input as StreamOnce>::Range: Range
[src]

type Output = (<Input as StreamOnce>::Range, P::Output)

type PartialState = (usize, P::PartialState)

impl<Input, P> Parser<Input> for SkipCount<Input, P> where
    <Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
    Input: Stream,
    P: Parser<Input>, 
[src]

type Output = ()

type PartialState = <With<Count<Sink, Input, P>, Value<Input, ()>> as Parser<Input>>::PartialState

impl<Input, P> Parser<Input> for SkipCountMinMax<Input, P> where
    <Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
    Input: Stream,
    P: Parser<Input>, 
[src]

type Output = ()

type PartialState = <With<CountMinMax<Sink, P>, Value<Input, ()>> as Parser<Input>>::PartialState

impl<Input, P> Parser<Input> for SkipMany1<Input, P> where
    <Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
    Input: Stream,
    P: Parser<Input>, 
[src]

type Output = ()

type PartialState = <Ignore<Many1<Sink, Ignore<P>>> as Parser<Input>>::PartialState

impl<Input, P> Parser<Input> for SkipMany<Input, P> where
    <Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
    Input: Stream,
    P: Parser<Input>, 
[src]

type Output = ()

type PartialState = <Ignore<Many<Sink, Ignore<P>>> as Parser<Input>>::PartialState

impl<Input, P> Parser<Input> for SkipUntil<Input, P> where
    <Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
    Input: Stream,
    P: Parser<Input>, 
[src]

type Output = ()

type PartialState = <With<TakeUntil<Sink, P>, Value<Input, ()>> as Parser<Input>>::PartialState

impl<Input, P> Parser<Input> for Satisfy<Input, P> where
    Input: Stream,
    P: FnMut(Input::Token) -> bool
[src]

type Output = Input::Token

type PartialState = ()

impl<Input, P, E> Parser<Input> for SkipRepeatUntil<Input, P, E> where
    <Input as StreamOnce>::Error: ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>,
    Input: Stream,
    P: Parser<Input>,
    E: Parser<Input>, 
[src]

type Output = ()

type PartialState = <With<RepeatUntil<Sink, P, E>, Value<Input, ()>> as Parser<Input>>::PartialState

impl<Input, P, F> Parser<Input> for combine::parser::combinator::Recognize<F, P> where
    Input: Stream,
    P: Parser<Input>,
    F: Default + Extend<<Input as StreamOnce>::Token>, 
[src]

type Output = F

type PartialState = (F, P::PartialState)

impl<Input, P, F> Parser<Input> for CountMinMax<F, P> where
    Input: Stream,
    P: Parser<Input>,
    F: Extend<P::Output> + Default
[src]

type Output = F

type PartialState = (usize, F, P::PartialState)

impl<Input, P, F, O, E> Parser<Input> for AndThen<P, F> where
    Input: Stream,
    P: Parser<Input>,
    F: FnMut(P::Output) -> Result<O, E>,
    E: Into<<Input::Error as ParseError<Input::Token, Input::Range, Input::Position>>::StreamError>,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>, 
[src]

type Output = O

type PartialState = P::PartialState

impl<Input, P, N, F> Parser<Input> for Then<P, F> where
    Input: Stream,
    F: FnMut(P::Output) -> N,
    P: Parser<Input>,
    N: Parser<Input>, 
[src]

type Output = N::Output

type PartialState = (P::PartialState, Option<(bool, N)>, N::PartialState)

impl<Input, P, N, F> Parser<Input> for ThenPartial<P, F> where
    Input: Stream,
    F: FnMut(&mut P::Output) -> N,
    P: Parser<Input>,
    N: Parser<Input>, 
[src]

type Output = N::Output

type PartialState = (P::PartialState, Option<(bool, P::Output)>, N::PartialState)

impl<Input, P, N, F> Parser<Input> for ThenRef<P, F> where
    Input: Stream,
    F: FnMut(&P::Output) -> N,
    P: Parser<Input>,
    N: Parser<Input>, 
[src]

type Output = (P::Output, N::Output)

type PartialState = (P::PartialState, Option<(bool, P::Output, N)>, N::PartialState)

impl<Input, P, Op> Parser<Input> for Chainl1<P, Op> where
    Input: Stream,
    P: Parser<Input>,
    Op: Parser<Input>,
    Op::Output: FnOnce(P::Output, P::Output) -> P::Output
[src]

type Output = P::Output

type PartialState = (Option<(P::Output, Commit<()>)>, <(Op, P) as Parser<Input>>::PartialState)

impl<Input, P, Op> Parser<Input> for Chainr1<P, Op> where
    Input: Stream,
    P: Parser<Input>,
    Op: Parser<Input>,
    Op::Output: FnOnce(P::Output, P::Output) -> P::Output
[src]

type Output = P::Output

type PartialState = ()

impl<Input, P, Q> Parser<Input> for Spanned<P> where
    P: Parser<Input>,
    Input: Stream<Position = Span<Q>>,
    Input::Error: ParseError<Input::Token, Input::Range, Span<Q>>,
    Q: Ord + Clone
[src]

type Output = P::Output

type PartialState = P::PartialState

impl<Input, P, Q> Parser<Input> for Escaped<P, Q, Input::Token> where
    Input: Stream,
    P: Parser<Input>,
    <Input as StreamOnce>::Token: PartialEq,
    Q: Parser<Input>, 
[src]

type Output = ()

type PartialState = EscapedState<P::PartialState, Q::PartialState>

impl<Input, P, R> Parser<Input> for SatisfyMap<Input, P> where
    Input: Stream,
    P: FnMut(Input::Token) -> Option<R>, 
[src]

type Output = R

type PartialState = ()

impl<Input, P, S> Parser<Input> for Expected<P, S> where
    P: Parser<Input>,
    Input: Stream,
    S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>, 
[src]

type Output = P::Output

type PartialState = P::PartialState

impl<Input, P, S> Parser<Input> for Message<P, S> where
    Input: Stream,
    P: Parser<Input>,
    S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>, 
[src]

type Output = P::Output

type PartialState = P::PartialState

impl<Input, T> Parser<Input> for NoneOf<T, Input> where
    T: Clone + IntoIterator<Item = Input::Token>,
    Input: Stream,
    Input::Token: PartialEq
[src]

type Output = Input::Token

type PartialState = ()

impl<Input, T> Parser<Input> for OneOf<T, Input> where
    T: Clone + IntoIterator<Item = Input::Token>,
    Input: Stream,
    Input::Token: PartialEq
[src]

type Output = Input::Token

type PartialState = ()

impl<Input, T> Parser<Input> for Value<Input, T> where
    Input: Stream,
    T: Clone
[src]

type Output = T

type PartialState = ()

impl<Input, T, E> Parser<Input> for Unexpected<Input, T, E> where
    Input: Stream,
    E: for<'s> ErrorInfo<'s, Input::Token, Input::Range>, 
[src]

type Output = T

type PartialState = ()

Loading content...