Struct chumsky::error::Cheap

pub struct Cheap<I, S = Range<usize>> { /* private fields */ }

A minimal error type that tracks only the error span and label. This type is most useful when you want fast parsing but do not particularly care about the quality of error messages.

Implementations

impl<I, S: Clone> Cheap<I, S>

pub fn span(&self) -> S

Returns the span that the error occurred at.

pub fn label(&self) -> Option<&'static str>

Returns the error’s label, if any.

Trait Implementations

impl<I: Clone, S: Clone> Clone for Cheap<I, S>

fn clone(&self) -> Cheap<I, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Debug, S: Debug> Debug for Cheap<I, S>

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

Formats the value using the given formatter.

impl<I, S: Span + Clone + Debug> Error<I> for Cheap<I, S>

type Span = S

The type of spans to be used in the error.

type Label = &'static str

The label used to describe a syntactic structure currently being parsed.

fn expected_input_found<Iter: IntoIterator<Item = Option<I>>>( span: Self::Span, _: Iter, _: Option<I> ) -> Self

Create a new error describing a conflict between expected inputs and that which was actually found.

fn with_label(self, label: Self::Label) -> Self

Indicate that the error occurred while parsing a particular syntactic structure.

fn merge(self, _: Self) -> Self

Merge two errors that point to the same input together, combining their information.

fn unclosed_delimiter( unclosed_span: Self::Span, unclosed: I, span: Self::Span, expected: I, found: Option<I> ) -> Self

Create a new error describing a delimiter that was not correctly closed.

impl<I: PartialEq, S: PartialEq> PartialEq<Cheap<I, S>> for Cheap<I, S>

fn eq(&self, other: &Cheap<I, S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<I: Eq, S: Eq> Eq for Cheap<I, S>

impl<I, S> StructuralEq for Cheap<I, S>

impl<I, S> StructuralPartialEq for Cheap<I, S>