Struct chumsky::BoxedParser

#[repr(transparent)]
pub struct BoxedParser<'a, I, O, E: Error<I>>(_);

See Parser::boxed.

This type is a repr(transparent) wrapper around its inner value.

Due to current implementation details, the inner value is not, in fact, a Box, but is an Rc to facilitate efficient cloning. This is likely to change in the future. Unlike Box, Rc has no size guarantees: although it is currently the same size as a raw pointer.

Trait Implementations

impl<'a, I, O, E: Error<I>> Clone for BoxedParser<'a, I, O, E>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, I: Clone, O, E: Error<I>> Parser<I, O> for BoxedParser<'a, I, O, E>

type Error = E

The type of errors emitted by this parser.

fn parse_recovery<'a, Iter: Iterator<Item = (I, <Self::Error as Error<I>>::Span)> + 'a, S: Into<Stream<'a, I, <Self::Error as Error<I>>::Span, Iter>>>(
    &self,
    stream: S
) -> (Option<O>, Vec<Self::Error>) where
    Self: Sized, 

Parse a stream of tokens, yielding an output if possible, and any errors encountered along the way.

fn parse_recovery_verbose<'a, Iter: Iterator<Item = (I, <Self::Error as Error<I>>::Span)> + 'a, S: Into<Stream<'a, I, <Self::Error as Error<I>>::Span, Iter>>>(
    &self,
    stream: S
) -> (Option<O>, Vec<Self::Error>) where
    Self: Sized, 

Parse a stream of tokens, yielding an output if possible, and any errors encountered along the way. Unlike Parser::parse_recovery, this function will produce verbose debugging output as it executes.

fn parse<'a, Iter: Iterator<Item = (I, <Self::Error as Error<I>>::Span)> + 'a, S: Into<Stream<'a, I, <Self::Error as Error<I>>::Span, Iter>>>(
    &self,
    stream: S
) -> Result<O, Vec<Self::Error>> where
    Self: Sized, 

Parse a stream of tokens, yielding an output or any errors that were encountered along the way.

fn debug<T: Display + 'static>(self, x: T) -> Debug<Self> where
    Self: Sized, 

Include this parser in the debugging output produced by Parser::parse_recovery_verbose.

fn map<U, F: Fn(O) -> U>(self, f: F) -> Map<Self, F, O> where
    Self: Sized, 

Map the output of this parser to another value.

fn map_with_span<U, F: Fn(O, <Self::Error as Error<I>>::Span) -> U>(
    self,
    f: F
) -> MapWithSpan<Self, F, O> where
    Self: Sized, 

Map the output of this parser to another value, making use of the pattern’s overall span.

fn map_err<F: Fn(Self::Error) -> Self::Error>(self, f: F) -> MapErr<Self, F> where
    Self: Sized, 

Map the primary error of this parser to another value.

fn try_map<U, F: Fn(O, <Self::Error as Error<I>>::Span) -> Result<U, Self::Error>>(
    self,
    f: F
) -> TryMap<Self, F, O> where
    Self: Sized, 

After a successful parse, apply a fallible function to the output. If the function produces an error, treat it as a parsing error.

fn validate<F: Fn(O, <Self::Error as Error<I>>::Span, &mut dyn FnMut(Self::Error)) -> O>(
    self,
    f: F
) -> Validate<Self, F> where
    Self: Sized, 

Validate an output, producing non-terminal errors if it does not fulfil certain criteria.

fn labelled<L: Into<<Self::Error as Error<I>>::Label> + Clone>(
    self,
    label: L
) -> Label<Self, L> where
    Self: Sized, 

Label the pattern parsed by this parser for more useful error messages.

fn to<U: Clone>(self, x: U) -> To<Self, O, U> where
    Self: Sized, 

Transform all outputs of this parser to a pretermined value.

fn foldl<A, B, F: Fn(A, B::Item) -> A>(self, f: F) -> Foldl<Self, F, A, B> where
    Self: Parser<I, (A, B)> + Sized,
    B: IntoIterator, 

Left-fold the output of the parser into a single value.

fn foldr<'a, A, B, F: Fn(A::Item, B) -> B + 'a>(
    self,
    f: F
) -> Foldr<Self, F, A, B> where
    Self: Parser<I, (A, B)> + Sized,
    A: IntoIterator,
    A::IntoIter: DoubleEndedIterator, 

Right-fold the output of the parser into a single value.

fn ignored(self) -> Ignored<Self, O> where
    Self: Sized, 

Ignore the output of this parser, yielding () as an output instead.

fn collect<C: FromIterator<O::Item>>(self) -> Map<Self, fn(_: O) -> C, O> where
    Self: Sized,
    O: IntoIterator, 

Collect the output of this parser into a type implementing FromIterator.

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

Parse one thing and then another thing, yielding a tuple of the two outputs.

fn chain<T, U, P: Parser<I, U, Error = Self::Error>>(
    self,
    other: P
) -> Map<Then<Self, P>, fn(_: (O, U)) -> Vec<T>, (O, U)> where
    Self: Sized,
    U: Chain<T>,
    O: Chain<T>, 

Parse one thing and then another thing, attempting to chain the two outputs into a Vec.

fn flatten<T, Inner>(self) -> Map<Self, fn(_: O) -> Vec<T>, O> where
    Self: Sized,
    O: IntoIterator<Item = Inner>,
    Inner: IntoIterator<Item = T>, 

Flatten a nested collection.

fn ignore_then<U, P: Parser<I, U>>(self, other: P) -> IgnoreThen<Self, P, O, U> where
    Self: Sized, 

Parse one thing and then another thing, yielding only the output of the latter.

fn then_ignore<U, P: Parser<I, U>>(self, other: P) -> ThenIgnore<Self, P, O, U> where
    Self: Sized, 

Parse one thing and then another thing, yielding only the output of the former.

fn padded_by<U, P: Parser<I, U, Error = Self::Error> + Clone>(
    self,
    other: P
) -> ThenIgnore<IgnoreThen<P, Self, U, O>, P, O, U> where
    Self: Sized, 

Parse a pattern, but with an instance of another pattern on either end, yielding the output of the inner.

fn delimited_by(self, start: I, end: I) -> DelimitedBy<Self, I> where
    Self: Sized, 

Parse the pattern surrounded by the given delimiters.

fn or<P: Parser<I, O>>(self, other: P) -> Or<Self, P> where
    Self: Sized, 

Parse one thing or, on failure, another thing.

fn recover_with<S: Strategy<I, O, Self::Error>>(
    self,
    strategy: S
) -> Recovery<Self, S> where
    Self: Sized, 

Apply a fallback recovery strategy to this parser should it fail.

fn or_not(self) -> OrNot<Self> where
    Self: Sized, 

Attempt to parse something, but only if it exists.

fn repeated(self) -> Repeated<Self> where
    Self: Sized, 

Parse an expression any number of times (including zero times).

fn separated_by<U, P: Parser<I, U>>(self, other: P) -> SeparatedBy<Self, P, U> where
    Self: Sized, 

Parse an expression, separated by another, any number of times.

fn boxed<'a>(self) -> BoxedParser<'a, I, O, Self::Error> where
    Self: Sized + 'a, 

Box the parser, yielding a parser that performs parsing through dynamic dispatch.