Struct Punctuated 

pub struct Punctuated<S> { /* private fields */ }

A sequence of syntax values separated by typed comma tokens.

Ordinary iteration exposes only values. Use Punctuated::pairs or Punctuated::into_pairs when punctuation and its spans are significant.

use m2_syn::{Span, ToTokens};

type Pluses = m2_syn::punct!(m2_syn::Token![+]);
let comma = m2_syn::Token![,](Span::detached());
let values: Pluses = m2_syn::punct!(
    pairs m2_syn::Token![+](Span::detached());
    comma => m2_syn::Token![+](Span::detached()),
);
assert_eq!(values.to_m2(), "+,+");

Implementations

impl<S> Punctuated<S>

pub const fn new() -> Self

Creates an empty sequence.

pub fn len(&self) -> usize

Returns the number of values, excluding punctuation.

pub fn is_empty(&self) -> bool

Reports whether the sequence contains no values or punctuation.

pub fn from_value(value: S) -> Self

Creates a sequence containing one value.

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

Borrows the values without exposing punctuation.

Examples found in repository

examples/type_inference.rs (line 76)

    fn components(&mut self, components: &Punctuated<Component>) -> Vec<FactOf<C>> {
        components
            .iter()
            .filter_map(|component| match component {
                Component::Expr(expression) => Some(self.infer(expression)),
                Component::EmptyComponent(_) => None,
            })
            .collect()
    }

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

Mutably borrows the values without exposing punctuation.

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

Borrows values together with their optional following commas.

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

Mutably borrows values together with their optional following commas.

pub fn into_pairs(self) -> IntoPairs<S>

Consumes the sequence while preserving commas in the yielded pairs.

pub fn push(&mut self, punctuation: _Cma, next: S)

Adds a comma and the component on its right.

Panics if the sequence is empty. Empty components must be represented explicitly by converting Empty into S before calling this method.

pub fn map<T>(self, map: impl FnMut(S) -> T) -> Punctuated<T>

Transforms the values while retaining every comma token and its span.

Trait Implementations

impl<S: Clone> Clone for Punctuated<S>

fn clone(&self) -> Punctuated<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for Punctuated<S>

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

Formats the value using the given formatter.

impl<S> Default for Punctuated<S>

fn default() -> Self

Returns the “default value” for a type.

impl<S: Eq> Eq for Punctuated<S>

impl<S> FromIterator<S> for Punctuated<S>

fn from_iter<T: IntoIterator<Item = S>>(iter: T) -> Self

Creates a value from an iterator.

impl<S> IntoIterator for Punctuated<S>

type Item = S

The type of the elements being iterated over.

type IntoIter = IntoIter<S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, S> IntoIterator for &'a Punctuated<S>

type Item = &'a S

The type of the elements being iterated over.

type IntoIter = Iter<'a, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, S> IntoIterator for &'a mut Punctuated<S>

type Item = &'a mut S

The type of the elements being iterated over.

type IntoIter = IterMut<'a, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<S> Parse for Punctuated<S>

where S: Parse + From<Empty>,

fn parse(input: &mut ParseStream) -> Result<Self, TokenParseError>

impl<S: PartialEq> PartialEq for Punctuated<S>

fn eq(&self, other: &Punctuated<S>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T: PrettyTree + Spanned> PrettyTree for Punctuated<T>

fn pretty_tree(&self) -> PrettyNode

Builds the presentation node for this syntax value.

impl<S> Spanned for Punctuated<S>

where Vec<(S, _Cma)>: Spanned, Option<Box<S>>: Spanned,

fn span(&self) -> Span

impl<S: PartialEq> StructuralPartialEq for Punctuated<S>

impl<S: ToTokens> ToTokens for Punctuated<S>

fn to_tokens(&self, output: &mut TokenStream)

fn to_token_stream(&self) -> TokenStream

fn to_m2(&self) -> String

fn to_code(&self) -> String