Struct Empty 

pub struct Empty(/* private fields */);

A parser that always succeeds without consuming any input.

Implementations

impl Empty

pub const fn new() -> Self

Creates a parser that always succeeds without consuming any input.

Trait Implementations

impl Clone for Empty

fn clone(&self) -> Empty

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Empty

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Empty

fn default() -> Empty

Returns the “default value” for a type.

impl Hash for Empty

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'inp, L, Ctx, Lang> ParseInput<'inp, L, (), Ctx, Lang> for Empty

where L: Lexer<'inp>, Ctx: ParseContext<'inp, L, Lang>, Lang: ?Sized,

fn parse_input( &mut self, _inp: &mut InputRef<'inp, '_, L, Ctx, Lang>, ) -> Result<(), <Ctx::Emitter as Emitter<'inp, L, Lang>>::Error>

where L: Lexer<'inp>, Ctx: ParseContext<'inp, L, Lang>,

Try to parse from the given input.

fn spanned(self) -> With<PhantomSpan, Self>

where Self: Sized,

Wraps the output of this parser in a Spanned with the span of the parsed input.

fn sourced(self) -> With<PhantomSliced, Self>

where Self: Sized,

Wraps the output of this parser in a Sliced with the source slice of the parsed input.

fn located(self) -> With<PhantomLocated, Self>

where Self: Sized,

Wraps the output of this parser in a Located with the span and source slice of the parsed input.

fn ignored(self) -> Ignore<Self, O>

where Self: Sized,

Ignores the output of this parser.

fn repeated<Condition, W>( self, condition: Condition, ) -> Repeated<Self, Condition, O, W>

where Self: Sized, L: Lexer<'inp>, Ctx: ParseContext<'inp, L, Lang>, Condition: Decision<'inp, L, Ctx::Emitter, W::CAPACITY>, W: Window,

Creates a Repeated combinator that applies this parser repeatedly until the condition handler Condition returns [RepeatedAction::End] or an fatal error.

fn separated_by<SepClassifier, Condition, W>( self, sep_classifier: SepClassifier, condition: Condition, ) -> SeparatedBy<Self, SepClassifier, Condition, O, W, L, Ctx>

where Self: Sized, L: Lexer<'inp>, Ctx: ParseContext<'inp, L, Lang>, Condition: Decision<'inp, L, Ctx::Emitter, W, Lang>, SepClassifier: Check<L::Token>, W: Window,

Creates a SeparatedBy combinator that applies this parser repeatedly,

fn separated_by_comma<Condition, W>( self, condition: Condition, ) -> SeparatedBy<Self, Comma, Condition, O, W, L, Ctx>

where Self: Sized, L: Lexer<'inp>, L::Token: PunctuatorToken<'inp>, Ctx: ParseContext<'inp, L, Lang>, Condition: Decision<'inp, L, Ctx::Emitter, W, Lang>, W: Window,

Creates a SeparatedBy combinator that applies this parser repeatedly,

fn peek_then<C, W>(self, condition: C) -> PeekThen<Self, C, L::Token, W>

where Self: Sized, L: Lexer<'inp>, Ctx: ParseContext<'inp, L, Lang>, C: FnMut(Peeked<'_, 'inp, L, W>, &mut Ctx::Emitter) -> Result<(), <Ctx::Emitter as Emitter<'inp, L, Lang>>::Error>, W: Window, PeekThen<Self, C, L::Token, W>: ParseInput<'inp, L, O, Ctx, Lang>,

Creates a PeekThen combinator that peeks at most N tokens first from the input before parsing.

fn peek_then_or_not<C, W>( self, condition: C, ) -> OrNot<PeekThen<Self, C, L::Token, W>>

where Self: Sized, L: Lexer<'inp>, Ctx: ParseContext<'inp, L, Lang>, C: Decision<'inp, L, Ctx::Emitter, W, Lang>, W: Window, OrNot<PeekThen<Self, C, L::Token, W>>: ParseInput<'inp, L, Option<O>, Ctx, Lang>,

Creates a PeekThen combinator that peeks at most N tokens first from the input before parsing.

fn map<U, F>(self, f: F) -> Map<Self, F, L, Ctx, O, U, Lang>

where Self: Sized, F: FnMut(O) -> U,

Map the output of this parser using the given function.

fn filter<F>(self, validator: F) -> Filter<Self, F>

where Self: Sized, L: Lexer<'inp>, F: FnMut(&O) -> Result<(), <Ctx::Emitter as Emitter<'inp, L, Lang>>::Error>, Ctx: ParseContext<'inp, L, Lang>,

Filter the output of this parser using a validation function.

fn filter_map<U, F>(self, mapper: F) -> FilterMap<Self, F, O>

where Self: Sized, L: Lexer<'inp>, F: FnMut(O) -> Result<U, <Ctx::Emitter as Emitter<'inp, L, Lang>>::Error>, Ctx: ParseContext<'inp, L, Lang>,

Filter and map the output of this parser using a validation/transformation function.

fn validate<F>(self, validator: F) -> Validate<Self, F>

where Self: Sized, L: Lexer<'inp>, F: FnMut(&O) -> Result<(), <Ctx::Emitter as Emitter<'inp, L, Lang>>::Error>, Ctx: ParseContext<'inp, L, Lang>,

Validate the output of this parser with full location context.

fn then_ignore<G, U>(self, second: G) -> ThenIgnore<Self, G, U>

where Self: Sized, G: ParseInput<'inp, L, U, Ctx, Lang>, Ctx: ParseContext<'inp, L, Lang>,

Sequence this parser with another, ignoring the output of the second.

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

where Self: Sized, T: ParseInput<'inp, L, U, Ctx, Lang>, Ctx: ParseContext<'inp, L, Lang>,

Sequence this parser with another, using the first result to determine the second parser.

fn ignore_then<G, U>(self, second: G) -> IgnoreThen<Self, G, O>

where Self: Sized, G: ParseInput<'inp, L, U, Ctx, Lang>,

Sequence this parser with another, ignoring the output of the first.

fn recover<R>(self, recovery: R) -> Recover<Self, R>

where Self: Sized, R: ParseInput<'inp, L, O, Ctx, Lang>, Ctx: ParseContext<'inp, L, Lang>,

Recover from errors produced by this parser using the given recovery parser.

fn inplace_recover<R>(self, recovery: R) -> InplaceRecover<Self, R>

where Self: Sized, R: ParseInput<'inp, L, O, Ctx, Lang>, Ctx: ParseContext<'inp, L, Lang>,

Recover in-place from errors produced by this parser using the given recovery parser.

fn padded(self) -> Padded<Self>

where Self: Sized,

Creates a parser that accepts any token with optional padding.

impl PartialEq for Empty

fn eq(&self, other: &Empty) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Empty

impl Eq for Empty

impl StructuralPartialEq for Empty