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

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

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

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

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

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

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

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

Map the output of this parser to another value.

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

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

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

Map the primary error of this parser to another value.

fn or_else<F>(self, f: F) -> OrElse<Self, F> where
    Self: Sized,
    F: Fn(Self::Error) -> Result<O, Self::Error>, 

Map the primary error of this parser to a result. If the result is Ok, the parser succeeds with that value.

fn map_err_with_span<F>(self, f: F) -> MapErrWithSpan<Self, F> where
    Self: Sized,
    F: Fn(Self::Error, <Self::Error as Error<I>>::Span) -> Self::Error, 

Map the primary error of this parser to another value, making use of the span from the start of the attempted to the point at which the error was encountered.

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

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, U>(self, f: F) -> Validate<Self, O, F> where
    Self: Sized,
    F: Fn(O, <Self::Error as Error<I>>::Span, &mut dyn FnMut(Self::Error)) -> U, 

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

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

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

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

Transform all outputs of this parser to a pretermined value.

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

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

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

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>(self) -> Map<Self, fn(_: O) -> C, O> where
    Self: Sized,
    O: IntoIterator,
    C: FromIterator<O::Item>, 

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

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

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

fn then_with<U, P, F: Fn(O) -> P>(
    self,
    other: F
) -> ThenWith<I, O, U, Self, P, F> where
    Self: Sized,
    P: Parser<I, U, Error = Self::Error>, 

Parse one thing and then another thing, creating the second parser from the result of the first. If you only have a couple cases to handle, prefer Parser::or.

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

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

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

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

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

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

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

fn delimited_by<U, V, L, R>(
    self,
    start: L,
    end: R
) -> DelimitedBy<Self, L, R, U, V> where
    Self: Sized,
    L: Parser<I, U, Error = Self::Error>,
    R: Parser<I, V, Error = Self::Error>, 

Parse the pattern surrounded by the given delimiters.

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

Parse one thing or, on failure, another thing.

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

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 a pattern any number of times (including zero times).

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

Parse a pattern, separated by another, any number of times.

fn rewind(self) -> Rewind<Self> where
    Self: Sized, 

Parse a pattern. Afterwards, the input stream will be rewound to its original state, as if parsing had not occurred.

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.

fn from_str<U>(self) -> Map<Self, fn(_: O) -> Result<U, U::Err>, O> where
    Self: Sized,
    U: FromStr,
    O: AsRef<str>, 

Attempt to convert the output of this parser into something else using Rust’s FromStr trait.

fn unwrapped<U, E>(self) -> Map<Self, fn(_: Result<U, E>) -> U, Result<U, E>> where
    Self: Sized + Parser<I, Result<U, E>>,
    E: Debug, 

For parsers that produce a Result as their output, unwrap the result (panicking if an Err is encountered).