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, 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_inner<S: Stream<I, <Self::Error as Error<I>>::Span>>(
    &self,
    stream: &mut S,
    errors: &mut Vec<Self::Error>
) -> (usize, Result<(O, Option<E>), E>)

Parse a stream with all the bells & whistles. You can use this to implement your own parser combinators. Note that both the signature and semantic requirements of this function are very likely to change in later versions. Where possible, prefer more ergonomic combinators provided elsewhere in the crate rather than implementing your own.

fn parse_recovery<S: IntoStream<I, <Self::Error as Error<I>>::Span>>(
    &self,
    stream: S
) -> (Option<O>, Vec<Self::Error>) where
    Self: Sized, 

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

fn parse<S: IntoStream<I, <Self::Error as Error<I>>::Span>>(
    &self,
    stream: S
) -> Result<O, Vec<Self::Error>> where
    Self: Sized, 

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

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

Map the output of this parser to aanother value.

fn map_with_span<U, F: Fn(O, Option<<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 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 labelled<L: Into<<Self::Error as Error<I>>::Pattern> + 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) -> A>(self, f: F) -> Foldl<Self, F, A, B> where
    Self: Parser<I, (A, Vec<B>)> + Sized, 

Left-fold the output of the parser into a single value, where the output is of type (_, Vec<_>).

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

Right-fold the output of the parser into a single value, where the output is of type (Vec<_>, _).

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 collection.

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 padding_for<U, P: Parser<I, U>>(self, other: P) -> PaddingFor<Self, P, O, U> where
    Self: Sized, 

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

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

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

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

Parse the pattern surrounded by the given delimiters, performing error recovery where possible.

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

Parse one thing or, on failure, another thing.

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 repeated_at_least(self, n: usize) -> Repeated<Self> where
    Self: Sized, 

Parse an expression at least a given 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.