Struct flexi_parse::punctuated::Punctuated

pub struct Punctuated<T, P: Punct> { /* private fields */ }

A series of pairs of T and P, optionally followed by another T.

Implementations

impl<T, P: Punct> Punctuated<T, P>

pub fn parse_separated(input: ParseStream<'_>) -> Result<Self>

where T: Parse,

Parses instances of T separated by instances of P, with no trailing punctuation.

Note that this will stop as soon as it encounters a token that doesn’t fit this pattern.

Errors

Forwards any errors from T::parse.

pub fn parse_separated_with<F: FnMut(ParseStream<'_>) -> Result<T>>( input: ParseStream<'_>, f: F ) -> Result<Self>

Parses instances of T using f, separated by instances of P, with no trailing punctuation.

Note that this will stop as soon as it encounters a token that doesn’t fit this pattern.

Errors

Forwards any errors from f.

pub fn parse_separated_trailing(input: ParseStream<'_>) -> Result<Self>

where T: Parse,

Parses instances of T separated by instances of P, with optional trailing punctuation.

Note that this will stop as soon as it encounters a token that doesn’t fit this pattern.

Errors

Forwards any errors from T::parse.

Examples found in repository

examples/lox/main.rs (line 362)

    fn finish_call(input: ParseStream<'_>, callee: Expr) -> Result<Self> {
        let content;
        let paren: Parentheses = group!(content in input);
        let arguments: Punctuated<Expr, Punct![","]> =
            Punctuated::parse_separated_trailing(&content)?;
        let arguments: Vec<_> = arguments.into_iter().collect();
        if arguments.len() >= 255 {
            input.add_error(input.new_error(
                "Can't have more than 254 arguments".to_string(),
                paren.0.clone(),
                error_codes::TOO_MANY_ARGS,
            ));
        }
        Ok(Expr::Call {
            callee: Box::new(callee),
            paren,
            arguments,
        })
    }

pub fn parse_separated_trailing_with<F: FnMut(ParseStream<'_>) -> Result<T>>( input: ParseStream<'_>, f: F ) -> Result<Self>

Parses instances of T using f, separated by instances of P, with optional trailing punctuation.

Note that this will stop as soon as it encounters a token that doesn’t fit this pattern.

Errors

Forwards any errors from f.

pub fn parse_terminated(input: ParseStream<'_>) -> Result<Self>

where T: Parse,

Parses instances of T separated by instances of P, with trailing punctuation.

Note that this function attempts to consume the entire stream.

Errors

Forwards any errors from T::parse.

pub fn parse_terminated_with<F: FnMut(ParseStream<'_>) -> Result<T>>( input: ParseStream<'_>, f: F ) -> Result<Self>

trailing punctuation.

Note that this function attempts to consume the entire stream.

Errors

Forwards any errors from f.

pub fn iter(&self) -> Iter<'_, T, P>

Returns an iterator over the values in this struct.

pub fn iter_mut(&mut self) -> IterMut<'_, T, P>

Returns an iterator that allows modifying each value.

pub fn pairs(&self) -> Pairs<'_, T, P>

Returns an iterator over the pairs of values and punctuation in this struct.

pub fn pairs_mut(&mut self) -> PairsMut<'_, T, P>

Returns an iterator that allows modifying each pair.

pub fn into_pairs(self) -> IntoPairs<T, P>

Returns a consuming iterator over the pairs in this struct.

Trait Implementations

impl<T: Clone, P: Clone + Punct> Clone for Punctuated<T, P>

fn clone(&self) -> Punctuated<T, P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, P: Debug + Punct> Debug for Punctuated<T, P>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, P: Punct> IntoIterator for Punctuated<T, P>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, P>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.