devela::_dep::winnow::prelude

Trait Parser

pub trait Parser<I, O, E> {

Show 24 methods    // Required method
    fn parse_next(&mut self, input: &mut I) -> Result<O, ErrMode<E>> ⓘ;

    // Provided methods
    fn parse(&mut self, input: I) -> Result<O, ParseError<I, E>> ⓘ
       where Self: Sized,
             I: Stream + StreamIsPartial,
             E: ParserError<I> { ... }
    fn parse_peek(&mut self, input: I) -> Result<(I, O), ErrMode<E>> ⓘ { ... }
    fn by_ref(&mut self) -> ByRef<'_, Self>
       where Self: Sized { ... }
    fn value<O2>(self, val: O2) -> Value<Self, I, O, O2, E>
       where Self: Sized,
             O2: Clone { ... }
    fn default_value<O2>(self) -> DefaultValue<Self, I, O, O2, E>
       where Self: Sized,
             O2: Default { ... }
    fn void(self) -> Void<Self, I, O, E>
       where Self: Sized { ... }
    fn output_into<O2>(self) -> OutputInto<Self, I, O, O2, E>
       where Self: Sized,
             O: Into<O2> { ... }
    fn take(self) -> Take<Self, I, O, E>
       where Self: Sized,
             I: Stream { ... }
    fn recognize(self) -> Take<Self, I, O, E>
       where Self: Sized,
             I: Stream { ... }
    fn with_taken(self) -> WithTaken<Self, I, O, E>
       where Self: Sized,
             I: Stream { ... }
    fn with_recognized(self) -> WithTaken<Self, I, O, E>
       where Self: Sized,
             I: Stream { ... }
    fn span(self) -> Span<Self, I, O, E>
       where Self: Sized,
             I: Stream + Location { ... }
    fn with_span(self) -> WithSpan<Self, I, O, E>
       where Self: Sized,
             I: Stream + Location { ... }
    fn map<G, O2>(self, map: G) -> Map<Self, G, I, O, O2, E>
       where G: FnMut(O) -> O2,
             Self: Sized { ... }
    fn try_map<G, O2, E2>(self, map: G) -> TryMap<Self, G, I, O, O2, E, E2>
       where Self: Sized,
             G: FnMut(O) -> Result<O2, E2>,
             I: Stream,
             E: FromExternalError<I, E2> { ... }
    fn verify_map<G, O2>(self, map: G) -> VerifyMap<Self, G, I, O, O2, E>
       where Self: Sized,
             G: FnMut(O) -> Option<O2>,
             I: Stream,
             E: ParserError<I> { ... }
    fn flat_map<G, H, O2>(self, map: G) -> FlatMap<Self, G, H, I, O, O2, E>
       where Self: Sized,
             G: FnMut(O) -> H,
             H: Parser<I, O2, E> { ... }
    fn and_then<G, O2>(self, inner: G) -> AndThen<Self, G, I, O, O2, E>
       where Self: Sized,
             G: Parser<O, O2, E>,
             O: StreamIsPartial,
             I: Stream { ... }
    fn parse_to<O2>(self) -> ParseTo<Self, I, O, O2, E>
       where Self: Sized,
             I: Stream,
             O: ParseSlice<O2>,
             E: ParserError<I> { ... }
    fn verify<G, O2>(self, filter: G) -> Verify<Self, G, I, O, O2, E>
       where Self: Sized,
             G: FnMut(&O2) -> bool,
             I: Stream,
             O: Borrow<O2>,
             E: ParserError<I>,
             O2: ?Sized { ... }
    fn context<C>(self, context: C) -> Context<Self, I, O, E, C>
       where Self: Sized,
             I: Stream,
             E: AddContext<I, C>,
             C: Clone + Debug { ... }
    fn complete_err(self) -> CompleteErr<Self>
       where Self: Sized { ... }
    fn err_into<E2>(self) -> ErrInto<Self, I, O, E, E2>
       where Self: Sized,
             E: Into<E2> { ... }

}
Available on crate feature dep_winnow only.
Expand description

Core trait for parsing

The simplest way to implement a Parser is with a function

use winnow::prelude::*;

fn empty(input: &mut &str) -> PResult<()> {
    let output = ();
    Ok(output)
}

let (input, output) = empty.parse_peek("Hello").unwrap();
assert_eq!(input, "Hello");  // We didn't consume any input

which can be made stateful by returning a function

use winnow::prelude::*;

fn empty<O: Clone>(output: O) -> impl FnMut(&mut &str) -> PResult<O> {
    move |input: &mut &str| {
        let output = output.clone();
        Ok(output)
    }
}

let (input, output) = empty("World").parse_peek("Hello").unwrap();
assert_eq!(input, "Hello");  // We didn't consume any input
assert_eq!(output, "World");

Additionally, some basic types implement Parser as well, including

Required Methods§

fn parse_next(&mut self, input: &mut I) -> Result<O, ErrMode<E>> ⓘ

Take tokens from the Stream, turning it into the output

This includes advancing the Stream to the next location.

On error, input will be left pointing at the error location.

Provided Methods§

fn parse(&mut self, input: I) -> Result<O, ParseError<I, E>> ⓘ
where Self: Sized, I: Stream + StreamIsPartial, E: ParserError<I>,

Parse all of input, generating O from it

fn parse_peek(&mut self, input: I) -> Result<(I, O), ErrMode<E>> ⓘ

Take tokens from the Stream, turning it into the output

This returns a copy of the Stream advanced to the next location.

Generally, prefer Parser::parse_next. This is primarily intended for:

  • Migrating from older versions / nom
  • Testing Parsers

For look-ahead parsing, see instead peek.

fn by_ref(&mut self) -> ByRef<'_, Self>
where Self: Sized,

Treat &mut Self as a parser

This helps when needing to move a Parser when all you have is a &mut Parser.

§Example

Because parsers are FnMut, they can be called multiple times. This prevents moving f into length_take and g into Parser::complete_err:

ⓘ
pub fn length_value<'i, O, E: ParserError<&'i [u8]>>(
    mut f: impl Parser<&'i [u8], usize, E>,
    mut g: impl Parser<&'i [u8], O, E>
) -> impl Parser<&'i [u8], O, E> {
  move |i: &mut &'i [u8]| {
    let mut data = length_take(f).parse_next(i)?;
    let o = g.complete_err().parse_next(&mut data)?;
    Ok(o)
  }
}

By adding by_ref, we can make this work:

pub fn length_value<'i, O, E: ParserError<&'i [u8]>>(
    mut f: impl Parser<&'i [u8], usize, E>,
    mut g: impl Parser<&'i [u8], O, E>
) -> impl Parser<&'i [u8], O, E> {
  move |i: &mut &'i [u8]| {
    let mut data = length_take(f.by_ref()).parse_next(i)?;
    let o = g.by_ref().complete_err().parse_next(&mut data)?;
    Ok(o)
  }
}

fn value<O2>(self, val: O2) -> Value<Self, I, O, O2, E>
where Self: Sized, O2: Clone,

Produce the provided value

§Example
use winnow::ascii::alpha1;

let mut parser = alpha1.value(1234);

assert_eq!(parser.parse_peek("abcd"), Ok(("", 1234)));
assert_eq!(parser.parse_peek("123abcd;"), Err(ErrMode::Backtrack(InputError::new("123abcd;", ErrorKind::Slice))));

fn default_value<O2>(self) -> DefaultValue<Self, I, O, O2, E>
where Self: Sized, O2: Default,

Produce a type’s default value

§Example
use winnow::ascii::alpha1;

let mut parser = alpha1.default_value::<u32>();

assert_eq!(parser.parse_peek("abcd"), Ok(("", 0)));
assert_eq!(parser.parse_peek("123abcd;"), Err(ErrMode::Backtrack(InputError::new("123abcd;", ErrorKind::Slice))));

fn void(self) -> Void<Self, I, O, E>
where Self: Sized,

Discards the output of the Parser

§Example
use winnow::ascii::alpha1;

let mut parser = alpha1.void();

assert_eq!(parser.parse_peek("abcd"), Ok(("", ())));
assert_eq!(parser.parse_peek("123abcd;"), Err(ErrMode::Backtrack(InputError::new("123abcd;", ErrorKind::Slice))));

fn output_into<O2>(self) -> OutputInto<Self, I, O, O2, E>
where Self: Sized, O: Into<O2>,

Convert the parser’s output to another type using std::convert::From

§Example
use winnow::ascii::alpha1;

fn parser1<'s>(i: &mut &'s str) -> PResult<&'s str, InputError<&'s str>> {
  alpha1(i)
}

let mut parser2 = parser1.output_into();

// the parser converts the &str output of the child parser into a Vec<u8>
let bytes: IResult<&str, Vec<u8>> = parser2.parse_peek("abcd");
assert_eq!(bytes, Ok(("", vec![97, 98, 99, 100])));

fn take(self) -> Take<Self, I, O, E>
where Self: Sized, I: Stream,

Produce the consumed input as produced value.

§Example
use winnow::ascii::{alpha1};
use winnow::combinator::separated_pair;

let mut parser = separated_pair(alpha1, ',', alpha1).take();

assert_eq!(parser.parse_peek("abcd,efgh"), Ok(("", "abcd,efgh")));
assert_eq!(parser.parse_peek("abcd;"),Err(ErrMode::Backtrack(InputError::new(";", ErrorKind::Tag))));

fn recognize(self) -> Take<Self, I, O, E>
where Self: Sized, I: Stream,

👎Deprecated since 0.6.14: Replaced with Parser::take

Replaced with Parser::take

fn with_taken(self) -> WithTaken<Self, I, O, E>
where Self: Sized, I: Stream,

Produce the consumed input with the output

Functions similarly to take except it returns the parser output as well.

This can be useful especially in cases where the output is not the same type as the input, or the input is a user defined type.

Returned tuple is of the format (produced output, consumed input).

§Example
use winnow::ascii::{alpha1};
use winnow::token::literal;
use winnow::combinator::separated_pair;

fn inner_parser<'s>(input: &mut &'s str) -> PResult<bool, InputError<&'s str>> {
    "1234".value(true).parse_next(input)
}

let mut consumed_parser = separated_pair(alpha1, ',', alpha1).value(true).with_taken();

assert_eq!(consumed_parser.parse_peek("abcd,efgh1"), Ok(("1", (true, "abcd,efgh"))));
assert_eq!(consumed_parser.parse_peek("abcd;"),Err(ErrMode::Backtrack(InputError::new(";", ErrorKind::Tag))));

// the second output (representing the consumed input)
// should be the same as that of the `take` parser.
let mut take_parser = inner_parser.take();
let mut consumed_parser = inner_parser.with_taken().map(|(output, consumed)| consumed);

assert_eq!(take_parser.parse_peek("1234"), consumed_parser.parse_peek("1234"));
assert_eq!(take_parser.parse_peek("abcd"), consumed_parser.parse_peek("abcd"));

fn with_recognized(self) -> WithTaken<Self, I, O, E>
where Self: Sized, I: Stream,

👎Deprecated since 0.6.14: Replaced with Parser::with_taken

Replaced with Parser::with_taken

fn span(self) -> Span<Self, I, O, E>
where Self: Sized, I: Stream + Location,

Produce the location of the consumed input as produced value.

§Example
use winnow::stream::LocatingSlice;
use winnow::ascii::alpha1;
use winnow::combinator::separated_pair;

let mut parser = separated_pair(alpha1.span(), ',', alpha1.span());

assert_eq!(parser.parse(LocatingSlice::new("abcd,efgh")), Ok((0..4, 5..9)));
assert_eq!(parser.parse_peek(LocatingSlice::new("abcd;")),Err(ErrMode::Backtrack(InputError::new(LocatingSlice::new("abcd;").peek_slice(4).0, ErrorKind::Tag))));

fn with_span(self) -> WithSpan<Self, I, O, E>
where Self: Sized, I: Stream + Location,

Produce the location of consumed input with the output

Functions similarly to Parser::span except it returns the parser output as well.

This can be useful especially in cases where the output is not the same type as the input, or the input is a user defined type.

Returned tuple is of the format (produced output, consumed input).

§Example
use winnow::stream::LocatingSlice;
use winnow::ascii::alpha1;
use winnow::token::literal;
use winnow::combinator::separated_pair;

fn inner_parser<'s>(input: &mut LocatingSlice<&'s str>) -> PResult<bool, InputError<LocatingSlice<&'s str>>> {
    "1234".value(true).parse_next(input)
}


let mut consumed_parser = separated_pair(alpha1.value(1).with_span(), ',', alpha1.value(2).with_span());

assert_eq!(consumed_parser.parse(LocatingSlice::new("abcd,efgh")), Ok(((1, 0..4), (2, 5..9))));
assert_eq!(consumed_parser.parse_peek(LocatingSlice::new("abcd;")),Err(ErrMode::Backtrack(InputError::new(LocatingSlice::new("abcd;").peek_slice(4).0, ErrorKind::Tag))));

// the second output (representing the consumed input)
// should be the same as that of the `span` parser.
let mut span_parser = inner_parser.span();
let mut consumed_parser = inner_parser.with_span().map(|(output, consumed)| consumed);

assert_eq!(span_parser.parse_peek(LocatingSlice::new("1234")), consumed_parser.parse_peek(LocatingSlice::new("1234")));
assert_eq!(span_parser.parse_peek(LocatingSlice::new("abcd")), consumed_parser.parse_peek(LocatingSlice::new("abcd")));

fn map<G, O2>(self, map: G) -> Map<Self, G, I, O, O2, E>
where G: FnMut(O) -> O2, Self: Sized,

Maps a function over the output of a parser

§Example
use winnow::{error::ErrMode,error::ErrorKind, error::InputError, Parser};
use winnow::ascii::digit1;

let mut parser = digit1.map(|s: &str| s.len());

// the parser will count how many characters were returned by digit1
assert_eq!(parser.parse_peek("123456"), Ok(("", 6)));

// this will fail if digit1 fails
assert_eq!(parser.parse_peek("abc"), Err(ErrMode::Backtrack(InputError::new("abc", ErrorKind::Slice))));

fn try_map<G, O2, E2>(self, map: G) -> TryMap<Self, G, I, O, O2, E, E2>
where Self: Sized, G: FnMut(O) -> Result<O2, E2>, I: Stream, E: FromExternalError<I, E2>,

Applies a function returning a Result over the output of a parser.

§Example
use winnow::ascii::digit1;

let mut parse = digit1.try_map(|s: &str| s.parse::<u8>());

// the parser will convert the result of digit1 to a number
assert_eq!(parse.parse_peek("123"), Ok(("", 123)));

// this will fail if digit1 fails
assert_eq!(parse.parse_peek("abc"), Err(ErrMode::Backtrack(InputError::new("abc", ErrorKind::Slice))));

// this will fail if the mapped function fails (a `u8` is too small to hold `123456`)
assert_eq!(parse.parse_peek("123456"), Err(ErrMode::Backtrack(InputError::new("123456", ErrorKind::Verify))));

fn verify_map<G, O2>(self, map: G) -> VerifyMap<Self, G, I, O, O2, E>
where Self: Sized, G: FnMut(O) -> Option<O2>, I: Stream, E: ParserError<I>,

Apply both Parser::verify and Parser::map.

§Example
use winnow::ascii::digit1;

let mut parse = digit1.verify_map(|s: &str| s.parse::<u8>().ok());

// the parser will convert the result of digit1 to a number
assert_eq!(parse.parse_peek("123"), Ok(("", 123)));

// this will fail if digit1 fails
assert_eq!(parse.parse_peek("abc"), Err(ErrMode::Backtrack(InputError::new("abc", ErrorKind::Slice))));

// this will fail if the mapped function fails (a `u8` is too small to hold `123456`)
assert_eq!(parse.parse_peek("123456"), Err(ErrMode::Backtrack(InputError::new("123456", ErrorKind::Verify))));

fn flat_map<G, H, O2>(self, map: G) -> FlatMap<Self, G, H, I, O, O2, E>
where Self: Sized, G: FnMut(O) -> H, H: Parser<I, O2, E>,

Creates a parser from the output of this one

§Example
use winnow::token::take;
use winnow::binary::u8;

fn length_take<'s>(input: &mut &'s [u8]) -> PResult<&'s [u8], InputError<&'s [u8]>> {
    u8.flat_map(take).parse_next(input)
}

assert_eq!(length_take.parse_peek(&[2, 0, 1, 2][..]), Ok((&[2][..], &[0, 1][..])));
assert_eq!(length_take.parse_peek(&[4, 0, 1, 2][..]), Err(ErrMode::Backtrack(InputError::new(&[0, 1, 2][..], ErrorKind::Slice))));

which is the same as

use winnow::token::take;
use winnow::binary::u8;

fn length_take<'s>(input: &mut &'s [u8]) -> PResult<&'s [u8], InputError<&'s [u8]>> {
    let length = u8.parse_next(input)?;
    let data = take(length).parse_next(input)?;
    Ok(data)
}

assert_eq!(length_take.parse_peek(&[2, 0, 1, 2][..]), Ok((&[2][..], &[0, 1][..])));
assert_eq!(length_take.parse_peek(&[4, 0, 1, 2][..]), Err(ErrMode::Backtrack(InputError::new(&[0, 1, 2][..], ErrorKind::Slice))));

fn and_then<G, O2>(self, inner: G) -> AndThen<Self, G, I, O, O2, E>
where Self: Sized, G: Parser<O, O2, E>, O: StreamIsPartial, I: Stream,

Applies a second parser over the output of the first one

§Example
use winnow::ascii::digit1;
use winnow::token::take;

let mut digits = take(5u8).and_then(digit1);

assert_eq!(digits.parse_peek("12345"), Ok(("", "12345")));
assert_eq!(digits.parse_peek("123ab"), Ok(("", "123")));
assert_eq!(digits.parse_peek("123"), Err(ErrMode::Backtrack(InputError::new("123", ErrorKind::Slice))));

fn parse_to<O2>(self) -> ParseTo<Self, I, O, O2, E>
where Self: Sized, I: Stream, O: ParseSlice<O2>, E: ParserError<I>,

Apply std::str::FromStr to the output of the parser

§Example
use winnow::{error::ErrMode,error::ErrorKind, error::InputError, Parser};
use winnow::ascii::digit1;

fn parser<'s>(input: &mut &'s str) -> PResult<u64, InputError<&'s str>> {
    digit1.parse_to().parse_next(input)
}

// the parser will count how many characters were returned by digit1
assert_eq!(parser.parse_peek("123456"), Ok(("", 123456)));

// this will fail if digit1 fails
assert_eq!(parser.parse_peek("abc"), Err(ErrMode::Backtrack(InputError::new("abc", ErrorKind::Slice))));

fn verify<G, O2>(self, filter: G) -> Verify<Self, G, I, O, O2, E>
where Self: Sized, G: FnMut(&O2) -> bool, I: Stream, O: Borrow<O2>, E: ParserError<I>, O2: ?Sized,

Returns the output of the child parser if it satisfies a verification function.

The verification function takes as argument a reference to the output of the parser.

§Example

let mut parser = alpha1.verify(|s: &str| s.len() == 4);

assert_eq!(parser.parse_peek("abcd"), Ok(("", "abcd")));
assert_eq!(parser.parse_peek("abcde"), Err(ErrMode::Backtrack(InputError::new("abcde", ErrorKind::Verify))));
assert_eq!(parser.parse_peek("123abcd;"),Err(ErrMode::Backtrack(InputError::new("123abcd;", ErrorKind::Slice))));

fn context<C>(self, context: C) -> Context<Self, I, O, E, C>
where Self: Sized, I: Stream, E: AddContext<I, C>, C: Clone + Debug,

If parsing fails, add context to the error

This is used mainly to add user friendly information to errors when backtracking through a parse tree.

fn complete_err(self) -> CompleteErr<Self>
where Self: Sized,

Transforms Incomplete into Backtrack

§Example

let mut parser = take(5u8).complete_err();

assert_eq!(parser.parse_peek(Partial::new("abcdefg")), Ok((Partial::new("fg"), "abcde")));
assert_eq!(parser.parse_peek(Partial::new("abcd")), Err(ErrMode::Backtrack(InputError::new(Partial::new("abcd"), ErrorKind::Complete))));

fn err_into<E2>(self) -> ErrInto<Self, I, O, E, E2>
where Self: Sized, E: Into<E2>,

Convert the parser’s error to another type using std::convert::From

Trait Implementations§

§

impl<I, O, E> Parser<I, O, E> for Box<dyn Parser<I, O, E> + '_>

§

fn parse_next(&mut self, i: &mut I) -> Result<O, ErrMode<E>> ⓘ

Take tokens from the Stream, turning it into the output Read more
§

fn parse(&mut self, input: I) -> Result<O, ParseError<I, E>> ⓘ
where Self: Sized, I: Stream + StreamIsPartial, E: ParserError<I>,

Parse all of input, generating O from it
§

fn parse_peek(&mut self, input: I) -> Result<(I, O), ErrMode<E>> ⓘ

Take tokens from the Stream, turning it into the output Read more
§

fn by_ref(&mut self) -> ByRef<'_, Self>
where Self: Sized,

Treat &mut Self as a parser Read more
§

fn value<O2>(self, val: O2) -> Value<Self, I, O, O2, E>
where Self: Sized, O2: Clone,

Produce the provided value Read more
§

fn default_value<O2>(self) -> DefaultValue<Self, I, O, O2, E>
where Self: Sized, O2: Default,

Produce a type’s default value Read more
§

fn void(self) -> Void<Self, I, O, E>
where Self: Sized,

Discards the output of the Parser Read more
§

fn output_into<O2>(self) -> OutputInto<Self, I, O, O2, E>
where Self: Sized, O: Into<O2>,

Convert the parser’s output to another type using std::convert::From Read more
§

fn take(self) -> Take<Self, I, O, E>
where Self: Sized, I: Stream,

Produce the consumed input as produced value. Read more
§

fn recognize(self) -> Take<Self, I, O, E>
where Self: Sized, I: Stream,

👎Deprecated since 0.6.14: Replaced with Parser::take
Replaced with Parser::take
§

fn with_taken(self) -> WithTaken<Self, I, O, E>
where Self: Sized, I: Stream,

Produce the consumed input with the output Read more
§

fn with_recognized(self) -> WithTaken<Self, I, O, E>
where Self: Sized, I: Stream,

👎Deprecated since 0.6.14: Replaced with Parser::with_taken
Replaced with Parser::with_taken
§

fn span(self) -> Span<Self, I, O, E>
where Self: Sized, I: Stream + Location,

Produce the location of the consumed input as produced value. Read more
§

fn with_span(self) -> WithSpan<Self, I, O, E>
where Self: Sized, I: Stream + Location,

Produce the location of consumed input with the output Read more
§

fn map<G, O2>(self, map: G) -> Map<Self, G, I, O, O2, E>
where G: FnMut(O) -> O2, Self: Sized,

Maps a function over the output of a parser Read more
§

fn try_map<G, O2, E2>(self, map: G) -> TryMap<Self, G, I, O, O2, E, E2>
where Self: Sized, G: FnMut(O) -> Result<O2, E2>, I: Stream, E: FromExternalError<I, E2>,

Applies a function returning a Result over the output of a parser. Read more
§

fn verify_map<G, O2>(self, map: G) -> VerifyMap<Self, G, I, O, O2, E>
where Self: Sized, G: FnMut(O) -> Option<O2>, I: Stream, E: ParserError<I>,

Apply both Parser::verify and Parser::map. Read more
§

fn flat_map<G, H, O2>(self, map: G) -> FlatMap<Self, G, H, I, O, O2, E>
where Self: Sized, G: FnMut(O) -> H, H: Parser<I, O2, E>,

Creates a parser from the output of this one Read more
§

fn and_then<G, O2>(self, inner: G) -> AndThen<Self, G, I, O, O2, E>
where Self: Sized, G: Parser<O, O2, E>, O: StreamIsPartial, I: Stream,

Applies a second parser over the output of the first one Read more
§

fn parse_to<O2>(self) -> ParseTo<Self, I, O, O2, E>
where Self: Sized, I: Stream, O: ParseSlice<O2>, E: ParserError<I>,

Apply std::str::FromStr to the output of the parser Read more
§

fn verify<G, O2>(self, filter: G) -> Verify<Self, G, I, O, O2, E>
where Self: Sized, G: FnMut(&O2) -> bool, I: Stream, O: Borrow<O2>, E: ParserError<I>, O2: ?Sized,

Returns the output of the child parser if it satisfies a verification function. Read more
§

fn context<C>(self, context: C) -> Context<Self, I, O, E, C>
where Self: Sized, I: Stream, E: AddContext<I, C>, C: Clone + Debug,

If parsing fails, add context to the error Read more
§

fn complete_err(self) -> CompleteErr<Self>
where Self: Sized,

Transforms Incomplete into Backtrack Read more
§

fn err_into<E2>(self) -> ErrInto<Self, I, O, E, E2>
where Self: Sized, E: Into<E2>,

Convert the parser’s error to another type using std::convert::From

Implementations on Foreign Types§

§

impl<'s, I, E> Parser<I, <I as Stream>::Slice, E> for &'s str
where E: ParserError<I>, I: Compare<&'s str> + StreamIsPartial + Stream,

This is a shortcut for literal.

§Example


fn parser<'s>(s: &mut &'s str) -> PResult<&'s str, InputError<&'s str>> {
  alt(("Hello", take(5usize))).parse_next(s)
}

assert_eq!(parser.parse_peek("Hello, World!"), Ok((", World!", "Hello")));
assert_eq!(parser.parse_peek("Something"), Ok(("hing", "Somet")));
assert_eq!(parser.parse_peek("Some"), Err(ErrMode::Backtrack(InputError::new("Some", ErrorKind::Slice))));
assert_eq!(parser.parse_peek(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Slice))));
§

fn parse_next(&mut self, i: &mut I) -> Result<<I as Stream>::Slice, ErrMode<E>> ⓘ

§

impl<'s, I, E> Parser<I, <I as Stream>::Slice, E> for &'s [u8]
where E: ParserError<I>, I: Compare<&'s [u8]> + StreamIsPartial + Stream,

This is a shortcut for literal.

§Example


fn parser<'s>(s: &mut &'s [u8]) -> PResult<&'s [u8], InputError<&'s [u8]>> {
  alt((&"Hello"[..], take(5usize))).parse_next(s)
}

assert_eq!(parser.parse_peek(&b"Hello, World!"[..]), Ok((&b", World!"[..], &b"Hello"[..])));
assert_eq!(parser.parse_peek(&b"Something"[..]), Ok((&b"hing"[..], &b"Somet"[..])));
assert_eq!(parser.parse_peek(&b"Some"[..]), Err(ErrMode::Backtrack(InputError::new(&b"Some"[..], ErrorKind::Slice))));
assert_eq!(parser.parse_peek(&b""[..]), Err(ErrMode::Backtrack(InputError::new(&b""[..], ErrorKind::Slice))));
§

fn parse_next(&mut self, i: &mut I) -> Result<<I as Stream>::Slice, ErrMode<E>> ⓘ

§

impl<'s, I, E, const N: usize> Parser<I, <I as Stream>::Slice, E> for &'s [u8; N]
where E: ParserError<I>, I: Compare<&'s [u8; N]> + StreamIsPartial + Stream,

This is a shortcut for literal.

§Example


fn parser<'s>(s: &mut &'s [u8]) -> PResult<&'s [u8], InputError<&'s [u8]>> {
  alt((b"Hello", take(5usize))).parse_next(s)
}

assert_eq!(parser.parse_peek(&b"Hello, World!"[..]), Ok((&b", World!"[..], &b"Hello"[..])));
assert_eq!(parser.parse_peek(&b"Something"[..]), Ok((&b"hing"[..], &b"Somet"[..])));
assert_eq!(parser.parse_peek(&b"Some"[..]), Err(ErrMode::Backtrack(InputError::new(&b"Some"[..], ErrorKind::Slice))));
assert_eq!(parser.parse_peek(&b""[..]), Err(ErrMode::Backtrack(InputError::new(&b""[..], ErrorKind::Slice))));
§

fn parse_next(&mut self, i: &mut I) -> Result<<I as Stream>::Slice, ErrMode<E>> ⓘ

§

impl<I, E> Parser<I, char, E> for char
where I: StreamIsPartial + Stream + Compare<char>, E: ParserError<I>,

This is a shortcut for one_of.

§Example

fn parser<'s>(i: &mut &'s str) -> PResult<char, InputError<&'s str>> {
    'a'.parse_next(i)
}
assert_eq!(parser.parse_peek("abc"), Ok(("bc", 'a')));
assert_eq!(parser.parse_peek(" abc"), Err(ErrMode::Backtrack(InputError::new(" abc", ErrorKind::Tag))));
assert_eq!(parser.parse_peek("bc"), Err(ErrMode::Backtrack(InputError::new("bc", ErrorKind::Tag))));
assert_eq!(parser.parse_peek(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Tag))));
§

fn parse_next(&mut self, i: &mut I) -> Result<char, ErrMode<E>> ⓘ

§

impl<I, E> Parser<I, u8, E> for u8
where I: StreamIsPartial + Stream + Compare<u8>, E: ParserError<I>,

This is a shortcut for one_of.

§Example

fn parser<'s>(i: &mut &'s [u8]) -> PResult<u8, InputError<&'s [u8]>>  {
    b'a'.parse_next(i)
}
assert_eq!(parser.parse_peek(&b"abc"[..]), Ok((&b"bc"[..], b'a')));
assert_eq!(parser.parse_peek(&b" abc"[..]), Err(ErrMode::Backtrack(InputError::new(&b" abc"[..], ErrorKind::Tag))));
assert_eq!(parser.parse_peek(&b"bc"[..]), Err(ErrMode::Backtrack(InputError::new(&b"bc"[..], ErrorKind::Tag))));
assert_eq!(parser.parse_peek(&b""[..]), Err(ErrMode::Backtrack(InputError::new(&b""[..], ErrorKind::Tag))));
§

fn parse_next(&mut self, i: &mut I) -> Result<u8, ErrMode<E>> ⓘ

§

impl<I, E> Parser<I, (), E> for ()
where I: Stream, E: ParserError<I>,

§

fn parse_next(&mut self, _i: &mut I) -> Result<(), ErrMode<E>> ⓘ

§

impl<I, O1, E, P1> Parser<I, (O1,), E> for (P1,)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>,

§

fn parse_next(&mut self, i: &mut I) -> Result<(O1,), ErrMode<E>> ⓘ

§

impl<I, O1, O2, E, P1, P2> Parser<I, (O1, O2), E> for (P1, P2)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>,

§

fn parse_next(&mut self, i: &mut I) -> Result<(O1, O2), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, E, P1, P2, P3> Parser<I, (O1, O2, O3), E> for (P1, P2, P3)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>,

§

fn parse_next(&mut self, i: &mut I) -> Result<(O1, O2, O3), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, E, P1, P2, P3, P4> Parser<I, (O1, O2, O3, O4), E> for (P1, P2, P3, P4)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>,

§

fn parse_next(&mut self, i: &mut I) -> Result<(O1, O2, O3, O4), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, E, P1, P2, P3, P4, P5> Parser<I, (O1, O2, O3, O4, O5), E> for (P1, P2, P3, P4, P5)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>,

§

fn parse_next(&mut self, i: &mut I) -> Result<(O1, O2, O3, O4, O5), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, E, P1, P2, P3, P4, P5, P6> Parser<I, (O1, O2, O3, O4, O5, O6), E> for (P1, P2, P3, P4, P5, P6)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>, P6: Parser<I, O6, E>,

§

fn parse_next( &mut self, i: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, E, P1, P2, P3, P4, P5, P6, P7> Parser<I, (O1, O2, O3, O4, O5, O6, O7), E> for (P1, P2, P3, P4, P5, P6, P7)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>, P6: Parser<I, O6, E>, P7: Parser<I, O7, E>,

§

fn parse_next( &mut self, i: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, E, P1, P2, P3, P4, P5, P6, P7, P8> Parser<I, (O1, O2, O3, O4, O5, O6, O7, O8), E> for (P1, P2, P3, P4, P5, P6, P7, P8)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>, P6: Parser<I, O6, E>, P7: Parser<I, O7, E>, P8: Parser<I, O8, E>,

§

fn parse_next( &mut self, i: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, E, P1, P2, P3, P4, P5, P6, P7, P8, P9> Parser<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9), E> for (P1, P2, P3, P4, P5, P6, P7, P8, P9)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>, P6: Parser<I, O6, E>, P7: Parser<I, O7, E>, P8: Parser<I, O8, E>, P9: Parser<I, O9, E>,

§

fn parse_next( &mut self, i: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, E, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> Parser<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10), E> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>, P6: Parser<I, O6, E>, P7: Parser<I, O7, E>, P8: Parser<I, O8, E>, P9: Parser<I, O9, E>, P10: Parser<I, O10, E>,

§

fn parse_next( &mut self, i: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, E, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> Parser<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11), E> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>, P6: Parser<I, O6, E>, P7: Parser<I, O7, E>, P8: Parser<I, O8, E>, P9: Parser<I, O9, E>, P10: Parser<I, O10, E>, P11: Parser<I, O11, E>,

§

fn parse_next( &mut self, i: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, E, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> Parser<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12), E> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>, P6: Parser<I, O6, E>, P7: Parser<I, O7, E>, P8: Parser<I, O8, E>, P9: Parser<I, O9, E>, P10: Parser<I, O10, E>, P11: Parser<I, O11, E>, P12: Parser<I, O12, E>,

§

fn parse_next( &mut self, i: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, E, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> Parser<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13), E> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>, P6: Parser<I, O6, E>, P7: Parser<I, O7, E>, P8: Parser<I, O8, E>, P9: Parser<I, O9, E>, P10: Parser<I, O10, E>, P11: Parser<I, O11, E>, P12: Parser<I, O12, E>, P13: Parser<I, O13, E>,

§

fn parse_next( &mut self, i: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, E, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> Parser<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14), E> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>, P6: Parser<I, O6, E>, P7: Parser<I, O7, E>, P8: Parser<I, O8, E>, P9: Parser<I, O9, E>, P10: Parser<I, O10, E>, P11: Parser<I, O11, E>, P12: Parser<I, O12, E>, P13: Parser<I, O13, E>, P14: Parser<I, O14, E>,

§

fn parse_next( &mut self, i: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, E, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> Parser<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15), E> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>, P6: Parser<I, O6, E>, P7: Parser<I, O7, E>, P8: Parser<I, O8, E>, P9: Parser<I, O9, E>, P10: Parser<I, O10, E>, P11: Parser<I, O11, E>, P12: Parser<I, O12, E>, P13: Parser<I, O13, E>, P14: Parser<I, O14, E>, P15: Parser<I, O15, E>,

§

fn parse_next( &mut self, i: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, E, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16> Parser<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16), E> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>, P6: Parser<I, O6, E>, P7: Parser<I, O7, E>, P8: Parser<I, O8, E>, P9: Parser<I, O9, E>, P10: Parser<I, O10, E>, P11: Parser<I, O11, E>, P12: Parser<I, O12, E>, P13: Parser<I, O13, E>, P14: Parser<I, O14, E>, P15: Parser<I, O15, E>, P16: Parser<I, O16, E>,

§

fn parse_next( &mut self, i: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, E, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17> Parser<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17), E> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>, P6: Parser<I, O6, E>, P7: Parser<I, O7, E>, P8: Parser<I, O8, E>, P9: Parser<I, O9, E>, P10: Parser<I, O10, E>, P11: Parser<I, O11, E>, P12: Parser<I, O12, E>, P13: Parser<I, O13, E>, P14: Parser<I, O14, E>, P15: Parser<I, O15, E>, P16: Parser<I, O16, E>, P17: Parser<I, O17, E>,

§

fn parse_next( &mut self, i: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, E, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18> Parser<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18), E> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>, P6: Parser<I, O6, E>, P7: Parser<I, O7, E>, P8: Parser<I, O8, E>, P9: Parser<I, O9, E>, P10: Parser<I, O10, E>, P11: Parser<I, O11, E>, P12: Parser<I, O12, E>, P13: Parser<I, O13, E>, P14: Parser<I, O14, E>, P15: Parser<I, O15, E>, P16: Parser<I, O16, E>, P17: Parser<I, O17, E>, P18: Parser<I, O18, E>,

§

fn parse_next( &mut self, i: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, E, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19> Parser<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19), E> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>, P6: Parser<I, O6, E>, P7: Parser<I, O7, E>, P8: Parser<I, O8, E>, P9: Parser<I, O9, E>, P10: Parser<I, O10, E>, P11: Parser<I, O11, E>, P12: Parser<I, O12, E>, P13: Parser<I, O13, E>, P14: Parser<I, O14, E>, P15: Parser<I, O15, E>, P16: Parser<I, O16, E>, P17: Parser<I, O17, E>, P18: Parser<I, O18, E>, P19: Parser<I, O19, E>,

§

fn parse_next( &mut self, i: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20, E, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20> Parser<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20), E> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>, P6: Parser<I, O6, E>, P7: Parser<I, O7, E>, P8: Parser<I, O8, E>, P9: Parser<I, O9, E>, P10: Parser<I, O10, E>, P11: Parser<I, O11, E>, P12: Parser<I, O12, E>, P13: Parser<I, O13, E>, P14: Parser<I, O14, E>, P15: Parser<I, O15, E>, P16: Parser<I, O16, E>, P17: Parser<I, O17, E>, P18: Parser<I, O18, E>, P19: Parser<I, O19, E>, P20: Parser<I, O20, E>,

§

fn parse_next( &mut self, i: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20), ErrMode<E>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20, O21, E, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21> Parser<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20, O21), E> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21)
where I: Stream, E: ParserError<I>, P1: Parser<I, O1, E>, P2: Parser<I, O2, E>, P3: Parser<I, O3, E>, P4: Parser<I, O4, E>, P5: Parser<I, O5, E>, P6: Parser<I, O6, E>, P7: Parser<I, O7, E>, P8: Parser<I, O8, E>, P9: Parser<I, O9, E>, P10: Parser<I, O10, E>, P11: Parser<I, O11, E>, P12: Parser<I, O12, E>, P13: Parser<I, O13, E>, P14: Parser<I, O14, E>, P15: Parser<I, O15, E>, P16: Parser<I, O16, E>, P17: Parser<I, O17, E>, P18: Parser<I, O18, E>, P19: Parser<I, O19, E>, P20: Parser<I, O20, E>, P21: Parser<I, O21, E>,

§

fn parse_next( &mut self, i: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20, O21), ErrMode<E>> ⓘ

Implementors§

§

impl<'s, I, E> Parser<I, <I as Stream>::Slice, E> for Caseless<&'s str>
where E: ParserError<I>, I: Compare<Caseless<&'s str>> + StreamIsPartial + Stream,

This is a shortcut for literal.

§Example


fn parser<'s>(s: &mut &'s str) -> PResult<&'s str, InputError<&'s str>> {
  alt((Caseless("hello"), take(5usize))).parse_next(s)
}

assert_eq!(parser.parse_peek("Hello, World!"), Ok((", World!", "Hello")));
assert_eq!(parser.parse_peek("hello, World!"), Ok((", World!", "hello")));
assert_eq!(parser.parse_peek("HeLlo, World!"), Ok((", World!", "HeLlo")));
assert_eq!(parser.parse_peek("Something"), Ok(("hing", "Somet")));
assert_eq!(parser.parse_peek("Some"), Err(ErrMode::Backtrack(InputError::new("Some", ErrorKind::Slice))));
assert_eq!(parser.parse_peek(""), Err(ErrMode::Backtrack(InputError::new("", ErrorKind::Slice))));
§

impl<'s, I, E> Parser<I, <I as Stream>::Slice, E> for Caseless<&'s [u8]>
where E: ParserError<I>, I: Compare<Caseless<&'s [u8]>> + StreamIsPartial + Stream,

This is a shortcut for literal.

§Example

use winnow::ascii::Caseless;

fn parser<'s>(s: &mut &'s [u8]) -> PResult<&'s [u8], InputError<&'s [u8]>> {
  alt((Caseless(&"hello"[..]), take(5usize))).parse_next(s)
}

assert_eq!(parser.parse_peek(&b"Hello, World!"[..]), Ok((&b", World!"[..], &b"Hello"[..])));
assert_eq!(parser.parse_peek(&b"hello, World!"[..]), Ok((&b", World!"[..], &b"hello"[..])));
assert_eq!(parser.parse_peek(&b"HeLlo, World!"[..]), Ok((&b", World!"[..], &b"HeLlo"[..])));
assert_eq!(parser.parse_peek(&b"Something"[..]), Ok((&b"hing"[..], &b"Somet"[..])));
assert_eq!(parser.parse_peek(&b"Some"[..]), Err(ErrMode::Backtrack(InputError::new(&b"Some"[..], ErrorKind::Slice))));
assert_eq!(parser.parse_peek(&b""[..]), Err(ErrMode::Backtrack(InputError::new(&b""[..], ErrorKind::Slice))));
§

impl<'s, I, E, const N: usize> Parser<I, <I as Stream>::Slice, E> for Caseless<&'s [u8; N]>
where E: ParserError<I>, I: Compare<Caseless<&'s [u8; N]>> + StreamIsPartial + Stream,

This is a shortcut for literal.

§Example

use winnow::ascii::Caseless;

fn parser<'s>(s: &mut &'s [u8]) -> PResult<&'s [u8], InputError<&'s [u8]>> {
  alt((Caseless(b"hello"), take(5usize))).parse_next(s)
}

assert_eq!(parser.parse_peek(&b"Hello, World!"[..]), Ok((&b", World!"[..], &b"Hello"[..])));
assert_eq!(parser.parse_peek(&b"hello, World!"[..]), Ok((&b", World!"[..], &b"hello"[..])));
assert_eq!(parser.parse_peek(&b"HeLlo, World!"[..]), Ok((&b", World!"[..], &b"HeLlo"[..])));
assert_eq!(parser.parse_peek(&b"Something"[..]), Ok((&b"hing"[..], &b"Somet"[..])));
assert_eq!(parser.parse_peek(&b"Some"[..]), Err(ErrMode::Backtrack(InputError::new(&b"Some"[..], ErrorKind::Slice))));
assert_eq!(parser.parse_peek(&b""[..]), Err(ErrMode::Backtrack(InputError::new(&b""[..], ErrorKind::Slice))));
§

impl<F, G, H, I, O, O2, E> Parser<I, O2, E> for FlatMap<F, G, H, I, O, O2, E>
where F: Parser<I, O, E>, G: FnMut(O) -> H, H: Parser<I, O2, E>,

§

impl<F, G, I, O, O2, E> Parser<I, O2, E> for AndThen<F, G, I, O, O2, E>
where F: Parser<I, O, E>, G: Parser<O, O2, E>, O: StreamIsPartial, I: Stream,

§

impl<F, G, I, O, O2, E> Parser<I, O2, E> for Map<F, G, I, O, O2, E>
where F: Parser<I, O, E>, G: FnMut(O) -> O2,

§

impl<F, G, I, O, O2, E> Parser<I, O2, E> for VerifyMap<F, G, I, O, O2, E>
where F: Parser<I, O, E>, G: FnMut(O) -> Option<O2>, I: Stream, E: ParserError<I>,

§

impl<F, G, I, O, O2, E> Parser<I, O, E> for Verify<F, G, I, O, O2, E>
where F: Parser<I, O, E>, G: FnMut(&O2) -> bool, I: Stream, O: Borrow<O2>, E: ParserError<I>, O2: ?Sized,

§

impl<F, G, I, O, O2, E, E2> Parser<I, O2, E> for TryMap<F, G, I, O, O2, E, E2>
where F: Parser<I, O, E>, G: FnMut(O) -> Result<O2, E2>, I: Stream, E: FromExternalError<I, E2>,

§

impl<F, I, O, E> Parser<I, (O, <I as Stream>::Slice), E> for WithTaken<F, I, O, E>
where F: Parser<I, O, E>, I: Stream,

§

impl<F, I, O, E> Parser<I, (O, Range<usize>), E> for WithSpan<F, I, O, E>
where F: Parser<I, O, E>, I: Stream + Location,

§

impl<F, I, O, E> Parser<I, (), E> for Void<F, I, O, E>
where F: Parser<I, O, E>,

§

impl<F, I, O, E> Parser<I, O, E> for CompleteErr<F>
where I: Stream, F: Parser<I, O, E>, E: ParserError<I>,

§

impl<F, I, O, E, C> Parser<I, O, E> for Context<F, I, O, E, C>
where F: Parser<I, O, E>, I: Stream, E: AddContext<I, C>, C: Clone + Debug,

§

impl<F, I, O, E, E2> Parser<I, O, E2> for ErrInto<F, I, O, E, E2>
where F: Parser<I, O, E>, E: Into<E2>,

§

impl<F, I, O, O2, E> Parser<I, O2, E> for DefaultValue<F, I, O, O2, E>
where F: Parser<I, O, E>, O2: Default,

§

impl<F, I, O, O2, E> Parser<I, O2, E> for OutputInto<F, I, O, O2, E>
where F: Parser<I, O, E>, O: Into<O2>,

§

impl<F, I, O, O2, E> Parser<I, O2, E> for Value<F, I, O, O2, E>
where F: Parser<I, O, E>, O2: Clone,

§

impl<I, O, E> Parser<I, O, E> for Box<dyn Parser<I, O, E> + '_>

§

impl<I, O, E, F> Parser<I, <I as Stream>::Slice, E> for Take<F, I, O, E>
where F: Parser<I, O, E>, I: Stream,

§

impl<I, O, E, F> Parser<I, Range<usize>, E> for Span<F, I, O, E>
where F: Parser<I, O, E>, I: Stream + Location,

§

impl<I, O, E, F> Parser<I, O, E> for F
where F: FnMut(&mut I) -> Result<O, ErrMode<E>>, I: Stream,

§

impl<I, O, E, P> Parser<I, O, E> for ByRef<'_, P>
where P: Parser<I, O, E>,

§

impl<P, I, O, C, E> Parser<I, C, E> for Repeat<P, I, O, C, E>
where P: Parser<I, O, E>, I: Stream, C: Accumulate<O>, E: ParserError<I>,

§

impl<P, I, O, O2, E> Parser<I, O2, E> for ParseTo<P, I, O, O2, E>
where P: Parser<I, O, E>, I: Stream, O: ParseSlice<O2>, E: ParserError<I>,