Struct chumsky::combinator::Repeated

pub struct Repeated<A>(_, _, _);

See Parser::repeated.

Implementations

impl<A> Repeated<A>

pub fn at_least(self, min: usize) -> Self

Require that the pattern appear at least a minimum number of times.

pub fn at_most(self, max: usize) -> Self

Require that the pattern appear at most a maximum number of times.

pub fn exactly(self, n: usize) -> Self

Require that the pattern appear exactly the given number of times.

let ring = just::<_, _, Simple<char>>('O');

let for_the_elves = ring
    .repeated()
    .exactly(3);

let for_the_dwarves = ring
    .repeated()
    .exactly(6);

let for_the_humans = ring
    .repeated()
    .exactly(9);

let for_sauron = ring
    .repeated()
    .exactly(1);

let rings = for_the_elves
    .then(for_the_dwarves)
    .then(for_the_humans)
    .then(for_sauron)
    .then_ignore(end());

assert!(rings.parse("OOOOOOOOOOOOOOOOOO").is_err()); // Too few rings!
assert!(rings.parse("OOOOOOOOOOOOOOOOOOOO").is_err()); // Too many rings!
// The perfect number of rings
assert_eq!(
    rings.parse("OOOOOOOOOOOOOOOOOOO"),
    Ok(((((vec!['O'; 3]), vec!['O'; 6]), vec!['O'; 9]), vec!['O'; 1])),
);

Trait Implementations

impl<A: Clone> Clone for Repeated<A>

fn clone(&self) -> Repeated<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Clone, O, A: Parser<I, O, Error = E>, E: Error<I>> Parser<I, Vec<O, Global>> for Repeated<A>

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 not(self) -> Not<Self, O>where
    Self: Sized,

Parses a single token if, and only if, the pattern fails to parse.

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 unwrapped<U, E>(self) -> Unwrapped<Self, E, <Self as Parser<I, O>>::Error>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).

impl<A: Copy> Copy for Repeated<A>