Struct InputRef 

pub struct InputRef<'src, 'parse, I: Input<'src>, E: ParserExtra<'src, I>> { /* private fields */ }

Internal type representing an input as well as all the necessary context for parsing.

Implementations

impl<'src, 'parse, I: Input<'src>, E: ParserExtra<'src, I>> InputRef<'src, 'parse, I, E>

pub fn cursor(&self) -> Cursor<'src, 'parse, I>

Get the internal cursor of the input at this moment in time.

Can be used for generating spans or slices. See InputRef::span_from and InputRef::slice.

pub fn save( &self, ) -> Checkpoint<'src, 'parse, I, <E::State as Inspector<'src, I>>::Checkpoint>

Save the current parse state as a Checkpoint.

You can rewind back to this state later with InputRef::rewind.

pub fn rewind( &mut self, checkpoint: Checkpoint<'src, 'parse, I, <E::State as Inspector<'src, I>>::Checkpoint>, )

Reset the parse state to that represented by the given Checkpoint.

You can create a checkpoint with which to perform rewinding using InputRef::save.

pub fn state(&mut self) -> &mut E::State

Get a mutable reference to the state associated with the current parse.

pub fn ctx(&self) -> &E::Context

Get a reference to the context fed to the current parser.

See ConfigParser::configure, Parser::ignore_with_ctx and Parser::then_with_ctx for more information about context-sensitive parsing.

pub fn parse<O, P: Parser<'src, I, O, E>>( &mut self, parser: P, ) -> Result<O, E::Error>

Attempt to parse this input using the given parser.

Important Notice

Parsers that return Err(...) are permitted to leave the input in an unspecified (but not undefined) state.

The only well-specified action you are permitted to perform on the input after an error has occurred is rewinding to a checkpoint created before the error occurred via InputRef::rewind.

This state is not consistent between releases of chumsky, compilations of the final binary, or even invocations of the parser. You should not rely on this state for anything, and choosing to rely on it means that your parser may break in unexpected ways at any time.

You have been warned.

pub fn check<O, P: Parser<'src, I, O, E>>( &mut self, parser: P, ) -> Result<(), E::Error>

A check-only version of InputRef::parse.

Import Notice

See InputRef::parse about unspecified behavior associated with this function.

pub fn next_maybe(&mut self) -> Option<MaybeRef<'src, I::Token>>

Get the next token in the input. Returns None if the end of the input has been reached.

This function is more flexible than either InputRef::next or InputRef::next_ref since it only requires that the Input trait be implemented for I (instead of either ValueInput or BorrowInput). However, that increased flexibility for the end user comes with a trade-off for the implementation: this function returns a MaybeRef<I::Token> that provides only a temporary reference to the token.

See InputRef::next_ref if you want get a reference to the next token instead.

pub fn next(&mut self) -> Option<I::Token>

where I: ValueInput<'src>,

Get the next token in the input by value. Returns None if the end of the input has been reached.

See InputRef::next_ref if you want get a reference to the next token instead.

pub fn next_ref(&mut self) -> Option<&'src I::Token>

where I: BorrowInput<'src>,

Get a reference to the next token in the input. Returns None if the end of the input has been reached.

See InputRef::next if you want get the next token by value instead.

pub fn peek_maybe(&mut self) -> Option<MaybeRef<'src, I::Token>>

Peek the next token in the input. Returns None if the end of the input has been reached.

See InputRef::next_maybe for more information about what this function guarantees.

pub fn peek(&mut self) -> Option<I::Token>

where I: ValueInput<'src>,

Peek the next token in the input. Returns None if the end of the input has been reached.

pub fn peek_ref(&mut self) -> Option<&'src I::Token>

where I: BorrowInput<'src>,

Peek the next token in the input. Returns None if the end of the input has been reached.

pub fn skip(&mut self)

where I: ValueInput<'src>,

Skip the next token in the input.

pub fn full_slice(&mut self) -> I::Slice

where I: SliceInput<'src>,

Get full slice of raw input.

pub fn slice(&mut self, range: Range<&Cursor<'src, 'parse, I>>) -> I::Slice

where I: SliceInput<'src>,

Get a slice of the input that covers the given cursor range.

pub fn slice_from( &mut self, range: RangeFrom<&Cursor<'src, 'parse, I>>, ) -> I::Slice

where I: SliceInput<'src>,

Get a slice of the input that covers the given cursor range.

pub fn slice_since( &mut self, range: RangeFrom<&Cursor<'src, 'parse, I>>, ) -> I::Slice

where I: SliceInput<'src>,

Get a slice of the input that covers the given cursor range.

pub fn span_from( &mut self, range: RangeFrom<&Cursor<'src, 'parse, I>>, ) -> I::Span

where I: ExactSizeInput<'src>,

Get a span over the input that goes from the given cursor to the end of the input.

pub fn span_since(&mut self, before: &Cursor<'src, 'parse, I>) -> I::Span

Generate a span that extends from the provided Cursor to the current input position.

pub fn emit(&mut self, error: E::Error)

Emits a non-fatal error at the current position. This is equivalent to emit_at(self.cursor(), error).

pub fn emit_at(&mut self, cursor: Cursor<'src, 'parse, I>, error: E::Error)

Emits a non-fatal error at the given cursor position.