Struct Todo 

pub struct Todo<O: ?Sized>(/* private fields */);

A placeholder parser that panics when executed - for unimplemented parsers.

This parser is a development tool for incrementally building parsers. It allows you to sketch out parser structure with type-correct placeholders that will panic if accidentally executed.

Similar to Rust’s todo!() macro, this parser:

• ✅ Compiles: Type-checks correctly in parser combinators
• ❌ Panics at runtime: Crashes if actually called during parsing
• 📍 Tracks location: Shows where the Todo was created (via #[track_caller])

Type Parameters

• O: The output type the parser would produce if implemented

Examples

Sketching Parser Structure

use tokora::parser::{todo_parser, ParseInput};

// Define high-level structure first
fn parse_function<'inp>() -> impl Parse<'inp, MyLexer, Function> {
    todo_parser()  // Implement later
}

// Use in larger parser
let parser = parse_struct()
    .or(parse_function())  // Compiles but panics if called
    .or(parse_enum());

Type-Driven Development

// Build parser incrementally
struct Module {
    imports: Vec<Import>,
    items: Vec<Item>,
}

fn parse_module<'inp>() -> impl Parse<'inp, MyLexer, Module> {
    todo_parser::<Import>()
        .repeated(stop_condition)
        .collect::<Vec<_>>()
        .then(parse_item().repeated(stop_condition).collect())
        .map(|(imports, items)| Module { imports, items })
}

// Compiles! Implement parse_item later.

Testing Partial Implementations

// Test the parts you've implemented
fn parse_statement<'inp>() -> impl Parse<'inp, MyLexer, Statement> {
    peek_then_choice((
        parse_let(),       // ✅ Implemented
        parse_if(),        // ✅ Implemented
        todo_parser(),     // 🚧 For/while loops - TODO
    ))
}

// Tests pass as long as they don't hit the todo

Panics

Always panics when parse_input() is called:

thread 'main' panicked at 'not yet implemented', src/parser.rs:42:5

The panic location points to where .parse() was called (thanks to #[track_caller]).

When to Use

✅ Good uses:

• Prototyping parser structure before implementation
• Incremental development of large grammars
• Placeholder for rarely-used grammar branches

❌ Don’t use for:

• Production code (obviously - it panics!)
• Parsers you intend to execute (use Empty for no-ops)
• Error handling (use proper error types)

Comparison with Empty

Parser	Runtime Behavior	Use Case
Empty	Always succeeds	Actual no-op parser
Todo	Always panics	Development placeholder

Performance

• Memory: Zero-sized type
• Runtime: N/A - panics before doing work

See Also

• Empty - Parser that actually does nothing (doesn’t panic)
• todo!() macro - Rust’s built-in todo placeholder

Implementations

impl<O: ?Sized> Todo<O>

pub const fn new() -> Self

Creates a parser that is not yet implemented.

Panics if parse_input() is called.

Trait Implementations

impl<O: Clone + ?Sized> Clone for Todo<O>

fn clone(&self) -> Todo<O>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<O: Copy + ?Sized> Copy for Todo<O>

impl<O: Debug + ?Sized> Debug for Todo<O>

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

Formats the value using the given formatter.

impl<O: Default + ?Sized> Default for Todo<O>

fn default() -> Todo<O>

Returns the “default value” for a type.

impl<O: Eq + ?Sized> Eq for Todo<O>

impl<O: Hash + ?Sized> Hash for Todo<O>

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, O, Ctx, Lang, Cmpl> ParseInput<'inp, L, O, Ctx, Lang, Cmpl> for Todo<O>

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

fn parse_input( &mut self, _inp: &mut InputRef<'inp, '_, L, Ctx, Lang, Cmpl>, ) -> Result<O, <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 delimited<D>( self, ) -> impl for<'c> FnMut(&mut InputRef<'inp, 'c, L, Ctx, Lang, Cmpl>) -> DelimitedOf<'inp, D, L, Ctx, Lang, O>

where Self: Sized, D: TypedDelimiter<'inp, L, Lang>, L: Lexer<'inp>, Ctx: ComposableParseContext<'inp, L, Lang>, Cmpl: SurfaceIncomplete<'inp, L, Ctx, Lang>,

Wraps this parser in a committed delimiter pair.

fn delimited_by_parens( self, ) -> impl for<'c> FnMut(&mut InputRef<'inp, 'c, L, Ctx, Lang, Cmpl>) -> DelimitedOf<'inp, Paren<(), (), Lang>, L, Ctx, Lang, O>

where Self: Sized, Paren<(), (), Lang>: TypedDelimiter<'inp, L, Lang>, L: Lexer<'inp>, Ctx: ComposableParseContext<'inp, L, Lang>, Cmpl: SurfaceIncomplete<'inp, L, Ctx, Lang>,

Wraps this parser in a committed Paren delimiter pair by delegating to ParseInput::delimited.

fn delimited_by_braces( self, ) -> impl for<'c> FnMut(&mut InputRef<'inp, 'c, L, Ctx, Lang, Cmpl>) -> DelimitedOf<'inp, Brace<(), (), Lang>, L, Ctx, Lang, O>

where Self: Sized, Brace<(), (), Lang>: TypedDelimiter<'inp, L, Lang>, L: Lexer<'inp>, Ctx: ComposableParseContext<'inp, L, Lang>, Cmpl: SurfaceIncomplete<'inp, L, Ctx, Lang>,

Wraps this parser in a committed Brace delimiter pair by delegating to ParseInput::delimited.

fn delimited_by_brackets( self, ) -> impl for<'c> FnMut(&mut InputRef<'inp, 'c, L, Ctx, Lang, Cmpl>) -> DelimitedOf<'inp, Bracket<(), (), Lang>, L, Ctx, Lang, O>

where Self: Sized, Bracket<(), (), Lang>: TypedDelimiter<'inp, L, Lang>, L: Lexer<'inp>, Ctx: ComposableParseContext<'inp, L, Lang>, Cmpl: SurfaceIncomplete<'inp, L, Ctx, Lang>,

Wraps this parser in a committed Bracket delimiter pair by delegating to ParseInput::delimited.

fn delimited_by_angles( self, ) -> impl for<'c> FnMut(&mut InputRef<'inp, 'c, L, Ctx, Lang, Cmpl>) -> DelimitedOf<'inp, Angle<(), (), Lang>, L, Ctx, Lang, O>

where Self: Sized, Angle<(), (), Lang>: TypedDelimiter<'inp, L, Lang>, L: Lexer<'inp>, Ctx: ComposableParseContext<'inp, L, Lang>, Cmpl: SurfaceIncomplete<'inp, L, Ctx, Lang>,

Wraps this parser in a committed Angle delimiter pair by delegating to ParseInput::delimited.

fn try_delimited<D>( self, ) -> impl for<'c> FnMut(&mut InputRef<'inp, 'c, L, Ctx, Lang, Cmpl>) -> TryDelimitedOf<'inp, D, L, Ctx, Lang, O>

where Self: Sized, D: TypedDelimiter<'inp, L, Lang>, L: Lexer<'inp>, Ctx: ComposableParseContext<'inp, L, Lang>, Cmpl: SurfaceIncomplete<'inp, L, Ctx, Lang>,

Wraps this parser in an attempted delimiter pair.

fn try_delimited_by_parens( self, ) -> impl for<'c> FnMut(&mut InputRef<'inp, 'c, L, Ctx, Lang, Cmpl>) -> TryDelimitedOf<'inp, Paren<(), (), Lang>, L, Ctx, Lang, O>

where Self: Sized, Paren<(), (), Lang>: TypedDelimiter<'inp, L, Lang>, L: Lexer<'inp>, Ctx: ComposableParseContext<'inp, L, Lang>, Cmpl: SurfaceIncomplete<'inp, L, Ctx, Lang>,

Wraps this parser in an attempted Paren delimiter pair by delegating to ParseInput::try_delimited.

fn try_delimited_by_braces( self, ) -> impl for<'c> FnMut(&mut InputRef<'inp, 'c, L, Ctx, Lang, Cmpl>) -> TryDelimitedOf<'inp, Brace<(), (), Lang>, L, Ctx, Lang, O>

where Self: Sized, Brace<(), (), Lang>: TypedDelimiter<'inp, L, Lang>, L: Lexer<'inp>, Ctx: ComposableParseContext<'inp, L, Lang>, Cmpl: SurfaceIncomplete<'inp, L, Ctx, Lang>,

Wraps this parser in an attempted Brace delimiter pair by delegating to ParseInput::try_delimited.

fn try_delimited_by_brackets( self, ) -> impl for<'c> FnMut(&mut InputRef<'inp, 'c, L, Ctx, Lang, Cmpl>) -> TryDelimitedOf<'inp, Bracket<(), (), Lang>, L, Ctx, Lang, O>

where Self: Sized, Bracket<(), (), Lang>: TypedDelimiter<'inp, L, Lang>, L: Lexer<'inp>, Ctx: ComposableParseContext<'inp, L, Lang>, Cmpl: SurfaceIncomplete<'inp, L, Ctx, Lang>,

Wraps this parser in an attempted Bracket delimiter pair by delegating to ParseInput::try_delimited.

fn try_delimited_by_angles( self, ) -> impl for<'c> FnMut(&mut InputRef<'inp, 'c, L, Ctx, Lang, Cmpl>) -> TryDelimitedOf<'inp, Angle<(), (), Lang>, L, Ctx, Lang, O>

where Self: Sized, Angle<(), (), Lang>: TypedDelimiter<'inp, L, Lang>, L: Lexer<'inp>, Ctx: ComposableParseContext<'inp, L, Lang>, Cmpl: SurfaceIncomplete<'inp, L, Ctx, Lang>,

Wraps this parser in an attempted Angle delimiter pair by delegating to ParseInput::try_delimited.

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

where Self: Sized, L: Lexer<'inp>,

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

fn sliced(self) -> With<PhantomSliced, Self, Cmpl>

where Self: Sized, L: Lexer<'inp>,

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

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

where Self: Sized, L: Lexer<'inp>,

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, L, Ctx, Lang, Cmpl>

where Self: Sized, L: Lexer<'inp>, Ignore<Self, O, L, Ctx, Lang, Cmpl>: ParseInput<'inp, L, (), Ctx, Lang, Cmpl>,

Ignores the output of this parser.

fn by_ref(&mut self) -> &mut ByRef<Self>

Creates a parser over a mutable reference to this parser.

fn fold_while<Condition, Init, Acc, W>( self, pred: Condition, init: Init, acc: Acc, ) -> FoldWhile<Self, Condition, Init, Acc, O, W, L, Ctx, Lang, Cmpl>

where Self: Sized, L: Lexer<'inp>, Ctx: ParseContext<'inp, L, Lang>, Condition: Decision<'inp, L, Ctx::Emitter, W, Lang>, W: Window, FoldWhile<Self, Condition, Init, Acc, O, W, L, Ctx, Lang, Cmpl>: ParseInput<'inp, L, O, Ctx, Lang, Cmpl>,

Available on crate feature fold only.

Creates a FoldWhile combinator that accumulates results while a condition is met.

fn try_fold_while<Condition, Init, Acc, W>( self, pred: Condition, init: Init, acc: Acc, ) -> TryFoldWhile<Self, Condition, Init, Acc, O, W, L, Ctx, Lang, Cmpl>

where Self: Sized, L: Lexer<'inp>, Ctx: ParseContext<'inp, L, Lang>, Init: FnMut() -> O, Acc: FnMut(O, O) -> Result<O, <Ctx::Emitter as Emitter<'inp, L, Lang>>::Error>, Condition: Decision<'inp, L, Ctx::Emitter, W, Lang>, W: Window, TryFoldWhile<Self, Condition, Init, Acc, O, W, L, Ctx, Lang, Cmpl>: ParseInput<'inp, L, O, Ctx, Lang, Cmpl>,

Available on crate feature fold only.

Creates a TryFoldWhile combinator that accumulates results while a condition is met.

fn try_fold_while_with<Condition, Init, Acc, W>( self, pred: Condition, init: Init, acc: Acc, ) -> TryFoldWhileWith<Self, Condition, Init, Acc, O, W, L, Ctx, Lang, Cmpl>

where Self: Sized, L: Lexer<'inp>, Ctx: ParseContext<'inp, L, Lang>, Init: FnMut() -> O, Acc: FnMut(O, O, ParseState<'_, 'inp, '_, L, Ctx, Lang, Cmpl>) -> Result<O, <Ctx::Emitter as Emitter<'inp, L, Lang>>::Error>, Condition: Decision<'inp, L, Ctx::Emitter, W, Lang>, W: Window, TryFoldWhileWith<Self, Condition, Init, Acc, O, W, L, Ctx, Lang, Cmpl>: ParseInput<'inp, L, O, Ctx, Lang, Cmpl>,

Available on crate feature fold only.

Creates a TryFoldWhileWith combinator that accumulates results while a condition is met, with access to parsing state.

fn rfold_while<Condition, Init, Acc, W>( self, condition: Condition, init: Init, acc: Acc, ) -> RFoldWhile<Self, Condition, Init, Acc, L, O, W, Ctx, Lang, Cmpl>

where Self: Sized, L: Lexer<'inp>, Ctx: ParseContext<'inp, L, Lang>, Init: FnMut() -> O, Acc: FnMut(O, O) -> O, Condition: Decision<'inp, L, Ctx::Emitter, W, Lang>, W: Window, RFoldWhile<Self, Condition, Init, Acc, L, O, W, Ctx, Lang, Cmpl>: ParseInput<'inp, L, O, Ctx, Lang, Cmpl>,

Available on crate feature fold and (crate features alloc or std) only.

Creates a RFoldWhile combinator that applies this parser repeatedly, while a condition is met, and folds results in reverse order.

fn repeated_while<Condition, W>( self, condition: Condition, ) -> RepeatedWhile<Self, Condition, O, W, L, Ctx, Lang, Cmpl>

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

Available on crate feature many only.

Creates a RepeatedWhile combinator that applies this parser repeatedly, where you provide the lookahead logic.

fn separated_while<Sep, Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, Sep, Condition, O, W, L, Ctx, Lang, Cmpl>

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

Available on crate feature many only.

Creates a SeparatedWhile combinator that parses separated elements, where you provide the lookahead logic.

fn separated_by_comma_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, Comma<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the comma separator and applies this parser repeatedly.

fn separated_by_semicolon_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, Semicolon<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the semicolon separator and applies this parser repeatedly.

fn separated_by_dot_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, Dot<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the dot separator and applies this parser repeatedly.

fn separated_by_colon_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, Colon<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the colon separator and applies this parser repeatedly.

fn separated_by_pipe_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, Pipe<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the pipe separator and applies this parser repeatedly.

fn separated_by_ampersand_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, Ampersand<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the ampersand separator and applies this parser repeatedly.

fn separated_by_hyphen_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, Hyphen<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the hyphen separator and applies this parser repeatedly.

fn separated_by_underscore_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, Underscore<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the underscore separator and applies this parser repeatedly.

fn separated_by_double_colon_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, DoubleColon<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the double_colon separator and applies this parser repeatedly.

fn separated_by_arrow_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, Arrow<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the arrow separator and applies this parser repeatedly.

fn separated_by_fat_arrow_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, FatArrow<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the fat_arrow separator and applies this parser repeatedly.

fn separated_by_tilde_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, Tilde<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the tilde separator and applies this parser repeatedly.

fn separated_by_slash_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, Slash<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the slash separator and applies this parser repeatedly.

fn separated_by_backslash_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, Backslash<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the backslash separator and applies this parser repeatedly.

fn separated_by_percent_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, Percent<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the percent separator and applies this parser repeatedly.

fn separated_by_dollar_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, Dollar<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the dollar separator and applies this parser repeatedly.

fn separated_by_hash_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, Hash<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the hash separator and applies this parser repeatedly.

fn separated_by_at_while<Condition, W>( self, condition: Condition, ) -> SeparatedWhile<Self, At<(), (), Lang>, Condition, O, W, L, Ctx, Lang, Cmpl>

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,

Available on crate feature many only.

Creates a SeparatedWhile combinator which separates elements by the at separator and applies this parser repeatedly.

fn labelled(self, name: &'static str) -> Labelled<Self>

where Self: Sized,

Method form of the free labelled.

fn traced(self, name: &'static str) -> Traced<Self>

where Self: Sized,

Available on crate feature trace only.

Method form of the free traced.

fn list_until<Until>( self, until: Until, ) -> impl for<'c> FnMut(&mut InputRef<'inp, 'c, L, Ctx, Lang>) -> ListOf<'inp, L, Ctx, Lang, O>

where Self: Sized + ParseInput<'inp, L, O, Ctx, Lang>, L: Lexer<'inp>, Ctx: ComposableParseContext<'inp, L, Lang>, Until: FnMut(&L::Token) -> bool,

Available on crate feature many and (crate features alloc or std) only.

Method form of the free list — named list_until because the until argument is the distinguishing half.

fn separated1_by<Sep, Peek>( self, peek: Peek, ) -> impl for<'c> FnMut(&mut InputRef<'inp, 'c, L, Ctx, Lang>) -> Separated1Of<'inp, L, Ctx, Lang, O>

where Self: Sized + ParseInput<'inp, L, O, Ctx, Lang>, L: Lexer<'inp>, Ctx: ComposableParseContext<'inp, L, Lang>, Sep: Punctuator<'inp, L, Lang>, Peek: FnMut(&L::Token) -> bool,

Available on crate feature many and (crate features alloc or std) only.

Method form of the free separated1 — the committed-first “light” list shape, fluent.

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

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

Available on crate feature peek only.

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

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

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

Available on crate feature peek only.

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

fn peek_then_head<C>( self, condition: C, ) -> PeekThen<Self, impl FnMut(Peeked<'_, 'inp, L, U1>, EmitterView<'_, 'inp, L, Ctx::Emitter, Lang>) -> Result<(), <Ctx::Emitter as Emitter<'inp, L, Lang>>::Error>, L::Token, U1, Cmpl>

where Self: Sized, L: Lexer<'inp>, Ctx: ParseContext<'inp, L, Lang>, C: FnMut(Option<Spanned<&L::Token, &L::Span>>) -> Result<(), <Ctx::Emitter as Emitter<'inp, L, Lang>>::Error>,

Available on crate feature peek only.

The width-1 twin of peek_then: the condition sees Some(head) or None (end of input) in grammar vocabulary.

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

where Self: Sized, F: FnMut(O) -> U, L: Lexer<'inp>, Map<Self, F, L, Ctx, O, U, Lang, Cmpl>: ParseInput<'inp, L, U, Ctx, Lang, Cmpl>,

Available on crate feature map only.

Map the output of this parser using the given function.

fn map_with<U, F>(self, f: F) -> MapWith<Self, F, L, Ctx, O, U, Lang, Cmpl>

where Self: Sized, L: Lexer<'inp>, F: FnMut(O, ParseState<'_, 'inp, '_, L, Ctx, Lang, Cmpl>) -> U, MapWith<Self, F, L, Ctx, O, U, Lang, Cmpl>: ParseInput<'inp, L, U, Ctx, Lang, Cmpl>,

Available on crate feature map only.

Map the output of this parser using the given function.

fn filter<F>(self, validator: F) -> Filter<Self, F, O, L, Ctx, Lang, Cmpl>

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

Available on crate feature filter only.

Filter the output of this parser using a validation function.

fn filter_with<F>( self, validator: F, ) -> FilterWith<Self, F, O, L, Ctx, Lang, Cmpl>

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

Available on crate feature filter only.

Filter the output of this parser using a validation function.

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

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

Available on crate feature filter only.

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

fn filter_map_with<U, F>( self, mapper: F, ) -> FilterMapWith<Self, F, O, U, L, Ctx, Lang, Cmpl>

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

Available on crate feature filter only.

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

fn validate<F>(self, validator: F) -> Validate<Self, F, O, L, Ctx, Lang, Cmpl>

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

Available on crate feature validate only.

Validate the output of this parser with full location context.

fn validate_with<F>( self, validator: F, ) -> ValidateWith<Self, F, O, L, Ctx, Lang, Cmpl>

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

Available on crate feature validate only.

Validate the output of this parser with full location context.

fn then_ignore<G, U>( self, second: G, ) -> ThenIgnore<Self, G, O, U, L, Ctx, Lang, Cmpl>

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

Available on crate feature then only.

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

fn then_value<F, U>( self, value: F, ) -> ThenValue<Self, F, O, U, L, Ctx, Lang, Cmpl>

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

Available on crate feature then only.

Sequence this parser with a fixed value, ignoring the output of the first.

fn and_then<T, U>(self, then: T) -> AndThen<Self, T, O, U, L, Ctx, Lang, Cmpl>

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

Available on crate feature then only.

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

fn and_then_with<T, U>( self, then: T, ) -> AndThenWith<Self, T, O, U, L, Ctx, Lang, Cmpl>

where Self: Sized, T: FnMut(O, ParseState<'_, 'inp, '_, L, Ctx, Lang, Cmpl>) -> Result<U, <Ctx::Emitter as Emitter<'inp, L, Lang>>::Error>, Ctx: ParseContext<'inp, L, Lang>, L: Lexer<'inp>, AndThenWith<Self, T, O, U, L, Ctx, Lang, Cmpl>: ParseInput<'inp, L, U, Ctx, Lang, Cmpl>,

Available on crate feature then only.

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

fn then<T, U>(self, then: T) -> Then<Self, T, O, U, L, Ctx, Lang, Cmpl>

where Self: Sized, L: Lexer<'inp>, T: ParseInput<'inp, L, U, Ctx, Lang, Cmpl>, Ctx: ParseContext<'inp, L, Lang>, Then<Self, T, O, U, L, Ctx, Lang, Cmpl>: ParseInput<'inp, L, (O, U), Ctx, Lang, Cmpl>,

Available on crate feature then only.

Sequence this parser with another, keeping both outputs.

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

where Self: Sized, L: Lexer<'inp>, G: ParseInput<'inp, L, U, Ctx, Lang, Cmpl>, IgnoreThen<Self, G, O, U, L, Ctx, Lang, Cmpl>: ParseInput<'inp, L, U, Ctx, Lang, Cmpl>,

Available on crate feature then only.

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

fn recover<R>(self, recovery: R) -> Recover<Self, R, O, L, Ctx, Lang, Cmpl>

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

Recover from errors by trying an alternative parser with backtracking.

fn inplace_recover<R>( self, recovery: R, ) -> InplaceRecover<Self, R, O, L, Ctx, Lang, Cmpl>

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

Recover from errors without backtracking, continuing from the error position.

fn skip_then_retry<D, F>( self, classifier: D, pred: F, ) -> SkipThenRetry<Self, D, F, O, L, Ctx, Lang, Cmpl>

where Self: Sized, L: Lexer<'inp>, D: DelimClass<<L::Token as Token<'inp>>::Kind>, F: FnMut(Spanned<&L::Token, &L::Span>) -> bool, Ctx: ParseContext<'inp, L, Lang>, SkipThenRetry<Self, D, F, O, L, Ctx, Lang, Cmpl>: ParseInput<'inp, L, O, Ctx, Lang, Cmpl>,

Recover from errors by skipping — nesting-aware — to a synchronization point and retrying this parser.

fn padded(self) -> Padded<Self, O, L, Ctx, Lang, Cmpl>

where Self: Sized, L: Lexer<'inp>, Padded<Self, O, L, Ctx, Lang, Cmpl>: ParseInput<'inp, L, O, Ctx, Lang, Cmpl>,

Creates a parser that accepts any token with optional padding.

fn padded_left(self) -> PaddedLeft<Self, O, L, Ctx, Lang, Cmpl>

where Self: Sized, L: Lexer<'inp>, PaddedLeft<Self, O, L, Ctx, Lang, Cmpl>: ParseInput<'inp, L, O, Ctx, Lang, Cmpl>,

Creates a parser that accepts any token with optional padding.

fn padded_right(self) -> PaddedRight<Self, O, L, Ctx, Lang, Cmpl>

where Self: Sized, L: Lexer<'inp>, PaddedRight<Self, O, L, Ctx, Lang, Cmpl>: ParseInput<'inp, L, O, Ctx, Lang, Cmpl>,

Creates a parser that accepts any token with optional padding.

impl<O: PartialEq + ?Sized> PartialEq for Todo<O>

fn eq(&self, other: &Todo<O>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<O: PartialEq + ?Sized> StructuralPartialEq for Todo<O>