pub struct Recursive<'a, I, O, E: Error<I>>(/* private fields */);
Expand description
A parser that can be defined in terms of itself by separating its declaration from its definition.
Prefer to use recursive()
, which exists as a convenient wrapper around both operations, if possible.
Implementations§
Source§impl<'a, I: Clone, O, E: Error<I>> Recursive<'a, I, O, E>
impl<'a, I: Clone, O, E: Error<I>> Recursive<'a, I, O, E>
Sourcepub fn declare() -> Self
pub fn declare() -> Self
Declare the existence of a recursive parser, allowing it to be used to construct parser combinators before being fulled defined.
Declaring a parser before defining it is required for a parser to reference itself.
This should be followed by exactly one call to the Recursive::define
method prior to using the parser
for parsing (i.e: via the Parser::parse
method or similar).
Prefer to use recursive()
, which is a convenient wrapper around this method and Recursive::define
, if
possible.
§Examples
#[derive(Debug, PartialEq)]
enum Chain {
End,
Link(char, Box<Chain>),
}
// Declare the existence of the parser before defining it so that it can reference itself
let mut chain = Recursive::<_, _, Simple<char>>::declare();
// Define the parser in terms of itself.
// In this case, the parser parses a right-recursive list of '+' into a singly linked list
chain.define(just('+')
.then(chain.clone())
.map(|(c, chain)| Chain::Link(c, Box::new(chain)))
.or_not()
.map(|chain| chain.unwrap_or(Chain::End)));
assert_eq!(chain.parse(""), Ok(Chain::End));
assert_eq!(
chain.parse("++"),
Ok(Chain::Link('+', Box::new(Chain::Link('+', Box::new(Chain::End))))),
);
Trait Implementations§
Source§impl<'a, I: Clone, O, E: Error<I>> Parser<I, O> for Recursive<'a, I, O, E>
impl<'a, I: Clone, O, E: Error<I>> Parser<I, O> for Recursive<'a, I, O, E>
Source§fn parse_recovery<'a, Iter, S>(
&self,
stream: S,
) -> (Option<O>, Vec<Self::Error>)
fn parse_recovery<'a, Iter, S>( &self, stream: S, ) -> (Option<O>, Vec<Self::Error>)
Parse a stream of tokens, yielding an output if possible, and any errors encountered along the way. Read more
Source§fn parse_recovery_verbose<'a, Iter, S>(
&self,
stream: S,
) -> (Option<O>, Vec<Self::Error>)
fn parse_recovery_verbose<'a, Iter, S>( &self, stream: S, ) -> (Option<O>, Vec<Self::Error>)
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. Read moreSource§fn parse<'a, Iter, S>(&self, stream: S) -> Result<O, Vec<Self::Error>>
fn parse<'a, Iter, S>(&self, stream: S) -> Result<O, Vec<Self::Error>>
Parse a stream of tokens, yielding an output or any errors that were encountered along the way. Read more
Source§fn debug<T>(self, x: T) -> Debug<Self>
fn debug<T>(self, x: T) -> Debug<Self>
Include this parser in the debugging output produced by
Parser::parse_recovery_verbose
. Read moreSource§fn map<U, F>(self, f: F) -> Map<Self, F, O>
fn map<U, F>(self, f: F) -> Map<Self, F, O>
Map the output of this parser to another value. Read more
Source§fn map_with_span<U, F>(self, f: F) -> MapWithSpan<Self, F, O>
fn map_with_span<U, F>(self, f: F) -> MapWithSpan<Self, F, O>
Map the output of this parser to another value, making use of the pattern’s span when doing so. Read more
Source§fn map_err<F>(self, f: F) -> MapErr<Self, F>
fn map_err<F>(self, f: F) -> MapErr<Self, F>
Map the primary error of this parser to another value. Read more
Source§fn map_err_with_span<F>(self, f: F) -> MapErrWithSpan<Self, F>
fn map_err_with_span<F>(self, f: F) -> MapErrWithSpan<Self, F>
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. Read more
Source§fn try_map<U, F>(self, f: F) -> TryMap<Self, F, O>
fn try_map<U, F>(self, f: F) -> TryMap<Self, F, O>
After a successful parse, apply a fallible function to the output. If the function produces an error, treat it
as a parsing error. Read more
Source§fn validate<F, U>(self, f: F) -> Validate<Self, O, F>
fn validate<F, U>(self, f: F) -> Validate<Self, O, F>
Validate an output, producing non-terminal errors if it does not fulfil certain criteria. Read more
Source§fn labelled<L>(self, label: L) -> Label<Self, L>
fn labelled<L>(self, label: L) -> Label<Self, L>
Label the pattern parsed by this parser for more useful error messages. Read more
Source§fn to<U>(self, x: U) -> To<Self, O, U>
fn to<U>(self, x: U) -> To<Self, O, U>
Transform all outputs of this parser to a pretermined value. Read more
Source§fn foldl<A, B, F>(self, f: F) -> Foldl<Self, F, A, B>
fn foldl<A, B, F>(self, f: F) -> Foldl<Self, F, A, B>
Left-fold the output of the parser into a single value. Read more
Source§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,
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. Read more
Source§fn ignored(self) -> Ignored<Self, O>where
Self: Sized,
fn ignored(self) -> Ignored<Self, O>where
Self: Sized,
Ignore the output of this parser, yielding
()
as an output instead. Read moreSource§fn collect<C>(self) -> Map<Self, fn(_: O) -> C, O>
fn collect<C>(self) -> Map<Self, fn(_: O) -> C, O>
Collect the output of this parser into a type implementing
FromIterator
. Read moreSource§fn then<U, P>(self, other: P) -> Then<Self, P>
fn then<U, P>(self, other: P) -> Then<Self, P>
Parse one thing and then another thing, yielding a tuple of the two outputs. Read more
Source§fn then_with<U, P, F: Fn(O) -> P>(
self,
other: F,
) -> ThenWith<I, O, U, Self, P, F>
fn then_with<U, P, F: Fn(O) -> P>( self, other: F, ) -> ThenWith<I, O, U, Self, P, F>
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
. Read moreSource§fn flatten<T, Inner>(self) -> Map<Self, fn(_: O) -> Vec<T>, O>
fn flatten<T, Inner>(self) -> Map<Self, fn(_: O) -> Vec<T>, O>
Flatten a nested collection. Read more
Source§fn ignore_then<U, P>(self, other: P) -> IgnoreThen<Self, P, O, U>
fn ignore_then<U, P>(self, other: P) -> IgnoreThen<Self, P, O, U>
Parse one thing and then another thing, yielding only the output of the latter. Read more
Source§fn then_ignore<U, P>(self, other: P) -> ThenIgnore<Self, P, O, U>
fn then_ignore<U, P>(self, other: P) -> ThenIgnore<Self, P, O, U>
Parse one thing and then another thing, yielding only the output of the former. Read more
Source§fn padded_by<U, P>(
self,
other: P,
) -> ThenIgnore<IgnoreThen<P, Self, U, O>, P, O, U>
fn padded_by<U, P>( self, other: P, ) -> ThenIgnore<IgnoreThen<P, Self, U, O>, P, O, U>
Parse a pattern, but with an instance of another pattern on either end, yielding the output of the inner. Read more
Source§fn delimited_by<U, V, L, R>(
self,
start: L,
end: R,
) -> DelimitedBy<Self, L, R, U, V>
fn delimited_by<U, V, L, R>( self, start: L, end: R, ) -> DelimitedBy<Self, L, R, U, V>
Parse the pattern surrounded by the given delimiters. Read more
Source§fn or<P>(self, other: P) -> Or<Self, P>
fn or<P>(self, other: P) -> Or<Self, P>
Parse one thing or, on failure, another thing. Read more
Source§fn recover_with<S>(self, strategy: S) -> Recovery<Self, S>
fn recover_with<S>(self, strategy: S) -> Recovery<Self, S>
Apply a fallback recovery strategy to this parser should it fail. Read more
Source§fn or_not(self) -> OrNot<Self>where
Self: Sized,
fn or_not(self) -> OrNot<Self>where
Self: Sized,
Attempt to parse something, but only if it exists. Read more
Source§fn not(self) -> Not<Self, O>where
Self: Sized,
fn not(self) -> Not<Self, O>where
Self: Sized,
Parses a single token if, and only if, the pattern fails to parse. Read more
Source§fn repeated(self) -> Repeated<Self>where
Self: Sized,
fn repeated(self) -> Repeated<Self>where
Self: Sized,
Parse a pattern any number of times (including zero times). Read more
Source§fn separated_by<U, P>(self, other: P) -> SeparatedBy<Self, P, U>
fn separated_by<U, P>(self, other: P) -> SeparatedBy<Self, P, U>
Parse a pattern, separated by another, any number of times. Read more
Source§fn rewind(self) -> Rewind<Self>where
Self: Sized,
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. Read more
Source§fn boxed<'a>(self) -> BoxedParser<'a, I, O, Self::Error>where
Self: Sized + 'a,
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. Read more
Auto Trait Implementations§
impl<'a, I, O, E> Freeze for Recursive<'a, I, O, E>
impl<'a, I, O, E> !RefUnwindSafe for Recursive<'a, I, O, E>
impl<'a, I, O, E> !Send for Recursive<'a, I, O, E>
impl<'a, I, O, E> !Sync for Recursive<'a, I, O, E>
impl<'a, I, O, E> Unpin for Recursive<'a, I, O, E>
impl<'a, I, O, E> !UnwindSafe for Recursive<'a, I, O, E>
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more