Struct Choice

pub struct Choice<T: IntoChoice<O>, O> { /* private fields */ }

Implementations

impl<T: IntoChoice<O>, O> Choice<T, O>

pub const fn new(parsers: T) -> Self

Trait Implementations

impl<T, O> Clone for Choice<T, O>

where T: Clone + IntoChoice<O>, PhantomData<O>: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A: Parser<Output>, B: Parser<Output>, C: Parser<Output>, D: Parser<Output>, E: Parser<Output>, F: Parser<Output>, G: Parser<Output>, H: Parser<Output>, I: Parser<Output>, J: Parser<Output>, K: Parser<Output>, L: Parser<Output>, M: Parser<Output>, N: Parser<Output>, O: Parser<Output>, P: Parser<Output>, Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<B: Parser<Output>, C: Parser<Output>, D: Parser<Output>, E: Parser<Output>, F: Parser<Output>, G: Parser<Output>, H: Parser<Output>, I: Parser<Output>, J: Parser<Output>, K: Parser<Output>, L: Parser<Output>, M: Parser<Output>, N: Parser<Output>, O: Parser<Output>, P: Parser<Output>, Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<C: Parser<Output>, D: Parser<Output>, E: Parser<Output>, F: Parser<Output>, G: Parser<Output>, H: Parser<Output>, I: Parser<Output>, J: Parser<Output>, K: Parser<Output>, L: Parser<Output>, M: Parser<Output>, N: Parser<Output>, O: Parser<Output>, P: Parser<Output>, Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<D: Parser<Output>, E: Parser<Output>, F: Parser<Output>, G: Parser<Output>, H: Parser<Output>, I: Parser<Output>, J: Parser<Output>, K: Parser<Output>, L: Parser<Output>, M: Parser<Output>, N: Parser<Output>, O: Parser<Output>, P: Parser<Output>, Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<E: Parser<Output>, F: Parser<Output>, G: Parser<Output>, H: Parser<Output>, I: Parser<Output>, J: Parser<Output>, K: Parser<Output>, L: Parser<Output>, M: Parser<Output>, N: Parser<Output>, O: Parser<Output>, P: Parser<Output>, Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<F: Parser<Output>, G: Parser<Output>, H: Parser<Output>, I: Parser<Output>, J: Parser<Output>, K: Parser<Output>, L: Parser<Output>, M: Parser<Output>, N: Parser<Output>, O: Parser<Output>, P: Parser<Output>, Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<G: Parser<Output>, H: Parser<Output>, I: Parser<Output>, J: Parser<Output>, K: Parser<Output>, L: Parser<Output>, M: Parser<Output>, N: Parser<Output>, O: Parser<Output>, P: Parser<Output>, Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<H: Parser<Output>, I: Parser<Output>, J: Parser<Output>, K: Parser<Output>, L: Parser<Output>, M: Parser<Output>, N: Parser<Output>, O: Parser<Output>, P: Parser<Output>, Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<I: Parser<Output>, J: Parser<Output>, K: Parser<Output>, L: Parser<Output>, M: Parser<Output>, N: Parser<Output>, O: Parser<Output>, P: Parser<Output>, Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<J: Parser<Output>, K: Parser<Output>, L: Parser<Output>, M: Parser<Output>, N: Parser<Output>, O: Parser<Output>, P: Parser<Output>, Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<K: Parser<Output>, L: Parser<Output>, M: Parser<Output>, N: Parser<Output>, O: Parser<Output>, P: Parser<Output>, Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<L: Parser<Output>, M: Parser<Output>, N: Parser<Output>, O: Parser<Output>, P: Parser<Output>, Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<M: Parser<Output>, N: Parser<Output>, O: Parser<Output>, P: Parser<Output>, Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<N: Parser<Output>, O: Parser<Output>, P: Parser<Output>, Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<O: Parser<Output>, P: Parser<Output>, Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(O, P, Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<P: Parser<Output>, Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(P, Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<Q: Parser<Output>, R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(Q, R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<R: Parser<Output>, S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(R, S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<S: Parser<Output>, T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(S, T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<T: Parser<Output>, U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(T, U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<U: Parser<Output>, V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(U, V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<V: Parser<Output>, W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(V, W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<W: Parser<Output>, X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(W, X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<X: Parser<Output>, Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(X, Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<Y: Parser<Output>, Z: Parser<Output>, Output> Parser<Output> for Choice<(Y, Z), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<Z: Parser<Output>, Output> Parser<Output> for Choice<(Z,), Output>

fn parse_inner(&self, input: &mut ParserInput<'_>) -> ParserResult<Output>

Inner parsing function, to implement

fn parse(&self, input: &mut ParserInput<'_>) -> ParserResult<T>

Parse an input with the current parser

fn parse_str(&self, str: &str) -> ParserResult<T>

Parse a string

fn parse_str_with_file_id(&self, str: &str, file_id: FileId) -> ParserResult<T>

Parse a string as a file

fn then<U, P: Parser<U>>(self, other: P) -> Then<T, Self, U, P>

where Self: Sized,

Chain this parser with another, getting both parsers’ results combined

fn then_ignore<U, P: Parser<U>>(self, other: P) -> ThenIgnore<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the latter’s parsed value

fn ignore_then<U, P: Parser<U>>(self, other: P) -> IgnoreThen<T, Self, U, P>

where Self: Sized,

Chain this parser with another but discard the former’s parsed value

fn followed_by<U, P: Parser<U>>(self, other: P) -> FollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser succeeds as well

fn not_followed_by<U, P: Parser<U>>( self, other: P, ) -> NotFollowedBy<T, Self, U, P>

where Self: Sized,

Only match if this parser succeeds and the provided parser doesn’t

fn repeated(self) -> Repeated<T, Self, NoAllocContainer>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_vec(self) -> Repeated<T, Self, Vec<T>>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn repeated_into_container<C: Container<T>>(self) -> Repeated<T, Self, C>

where Self: Sized,

Parse as many times as possible, until the parser eventually fails

fn or_not(self) -> OrNot<T, Self>

where Self: Sized,

Try to parse

fn map<U, F: Fn(T) -> U>(self, mapper: F) -> Map<T, Self, U, F>

where Self: Sized,

Map the parsed value using a function

fn map_str<U, F: Fn(&str) -> U>(self, mapper: F) -> MapStr<T, Self, U, F>

where Self: Sized,

Get the input string matched by the parser and map it using a function

fn try_map<U, F: Fn(T) -> Option<U>>(self, mapper: F) -> TryMap<T, Self, U, F>

where Self: Sized,

Try to map the parsed value using a function

fn and_then<U, F: Fn(T) -> Result<U, ParsingError>>( self, mapper: F, ) -> AndThen<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function

fn and_then_or_critical<U, F: Fn(T) -> Result<U, Cow<'static, str>>>( self, mapper: F, ) -> AndThenOrCritical<T, Self, U, F>

where Self: Sized,

Transform and validate the parsed value using the provided function Failures are critical

fn spanned(self) -> Spanned<T, Self>

where Self: Sized,

Wrap the parsed value in a Spanned

fn collect<C>(self) -> Map<T, Self, C, fn(T) -> C>

where Self: Sized, T: IntoIterator, C: FromIterator<T::Item>,

Collect the parsed value using the provided iterator type

fn collect_string(self) -> StringCollected<T, Self>

where Self: Sized,

Collect the input string matched by the parser

fn atomic_err(self, message: &'static str) -> AtomicErr<T, Self>

where Self: Sized,

Provide an atomic error if the parser fails

fn critical(self, message: &'static str) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn critical_auto_msg(self) -> Critical<T, Self>

where Self: Sized,

Mark the parser as critical

fn silent(self) -> Silenced<T, Self>

where Self: Sized,

Make the parser silent

fn padded_by<P, PP: Parser<P>>(self, padding: PP) -> Padded<T, Self, P, PP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided padding

fn line_padded(self) -> LinePadded<T, Self>

where Self: Sized,

Allow the parser to be surrounded by whitespaces (not newlines)

fn surrounded_by<L, LP: Parser<L>, R, RP: Parser<R>>( self, left: LP, right: RP, ) -> SurroundedBy<L, LP, T, Self, R, RP>

where Self: Sized,

Require the parser to be preceded by and followed by the provided parsers

fn separated_by<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, NoAllocContainer>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_vec<S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, Vec<T>>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn separated_by_into_container<C: Container<T>, S, P: Parser<S>>( self, sep: P, ) -> SeparatedBy<T, Self, S, P, C>

where Self: Sized,

Repeat the parser with the required provided separator between each repetition

fn flatten<U, S>(self) -> Flattened<U, S, T, Self, NoAllocContainer>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser

fn flatten_into_vec<U, S>(self) -> Flattened<U, S, T, Self, Vec<U>>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn flatten_into_container<U, S, C: Container<U>>( self, ) -> Flattened<U, S, T, Self, C>

where Self: Sized, T: IntoIterator<Item = S>, S: IntoIterator<Item = U>,

Flatten the parser Requires the parser to return a nested iterator.

fn to<U: Copy>(self, data: U) -> To<T, Self, U>

where Self: Sized,

Discard the parsed value and replace it with a fixed value

fn full(self) -> Full<T, Self>

where Self: Sized,

Require the parser to match the entire input

fn or<P: Parser<T>>(self, other: P) -> Choice<(Self, P), T>

where Self: Sized,

Allow the parser to fallback to another parser in case of failure

fn validate<F: Fn(&T) -> bool>(self, validator: F) -> Validate<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate

fn validate_or_critical<F: Fn(&T) -> bool>( self, validator: F, message: &'static str, ) -> ValidateOrCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a provided critical error message

fn validate_or_dynamic_critical<F: Fn(&T) -> Result<(), Cow<'static, str>>>( self, validator: F, ) -> ValidateOrDynamicCriticalMsg<T, Self, F>

where Self: Sized,

Validate the parsed value with a predicate or return a critical error message

fn debug<F: for<'a, 'b> Fn(DebugType<'a, 'b, T>)>( self, debugger: F, ) -> Debugging<T, Self, F>

where Self: Sized,

Debug the input and output values of the parser using the provided debugger

fn erase_type(self) -> Box<dyn Parser<T> + Send + Sync>

where Self: Sized + Send + Sync + 'static,

“Erase” the parser’s type

fn static_ref(&'static self) -> StaticRef<T, Self>

where Self: Sized,

Wrap a static reference to this parser inside a new parser

impl<T, O> Copy for Choice<T, O>

where T: Copy + IntoChoice<O>, PhantomData<O>: Copy,