Struct SeparatedBy

pub struct SeparatedBy<A, B, U> { /* private fields */ }

See Parser::separated_by.

Implementations

impl<A, B, U> SeparatedBy<A, B, U>

pub fn allow_leading(self) -> Self

Allow a leading separator to appear before the first item.

Note that even if no items are parsed, a leading separator is permitted.

Examples

let r#enum = text::keyword::<_, _, Simple<char>>("enum")
    .padded()
    .ignore_then(text::ident()
        .padded()
        .separated_by(just('|'))
        .allow_leading());

assert_eq!(r#enum.parse("enum True | False"), Ok(vec!["True".to_string(), "False".to_string()]));
assert_eq!(r#enum.parse("
    enum
    | True
    | False
"), Ok(vec!["True".to_string(), "False".to_string()]));

pub fn allow_trailing(self) -> Self

Allow a trailing separator to appear after the last item.

Note that if no items are parsed, no leading separator is permitted.

Examples

let numbers = text::int::<_, Simple<char>>(10)
    .padded()
    .separated_by(just(','))
    .allow_trailing()
    .delimited_by(just('('), just(')'));

assert_eq!(numbers.parse("(1, 2)"), Ok(vec!["1".to_string(), "2".to_string()]));
assert_eq!(numbers.parse("(1, 2,)"), Ok(vec!["1".to_string(), "2".to_string()]));

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

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

let numbers = just::<_, _, Simple<char>>('-')
    .separated_by(just('.'))
    .at_least(2);

assert!(numbers.parse("").is_err());
assert!(numbers.parse("-").is_err());
assert_eq!(numbers.parse("-.-"), Ok(vec!['-', '-']));

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

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

let row_4 = text::int::<_, Simple<char>>(10)
    .padded()
    .separated_by(just(','))
    .at_most(4);

let matrix_4x4 = row_4
    .separated_by(just(','))
    .at_most(4);

assert_eq!(
    matrix_4x4.parse("0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15"),
    Ok(vec![
        vec!["0".to_string(), "1".to_string(), "2".to_string(), "3".to_string()],
        vec!["4".to_string(), "5".to_string(), "6".to_string(), "7".to_string()],
        vec!["8".to_string(), "9".to_string(), "10".to_string(), "11".to_string()],
        vec!["12".to_string(), "13".to_string(), "14".to_string(), "15".to_string()],
    ]),
);

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

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

let coordinate_3d = text::int::<_, Simple<char>>(10)
    .padded()
    .separated_by(just(','))
    .exactly(3)
    .then_ignore(end());

// Not enough elements
assert!(coordinate_3d.parse("4, 3").is_err());
// Too many elements
assert!(coordinate_3d.parse("7, 2, 13, 4").is_err());
// Just the right number of elements
assert_eq!(coordinate_3d.parse("5, 0, 12"), Ok(vec!["5".to_string(), "0".to_string(), "12".to_string()]));

Trait Implementations

impl<A: Clone, B: Clone, U> Clone for SeparatedBy<A, B, U>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Clone, O, U, A: Parser<I, O, Error = E>, B: Parser<I, U, Error = E>, E: Error<I>> Parser<I, Vec<O>> for SeparatedBy<A, B, U>

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 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) -> 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, B: Copy, U> Copy for SeparatedBy<A, B, U>