Struct Punctuated 

pub struct Punctuated<S, P = _Cma> { /* private fields */ }

Two or more syntax values separated by typed punctuation.

Every separator is stored as its actual token, including its source span. At least one separator and the values on both sides are mandatory. A single value belongs directly in the surrounding syntax type, while an optional whole sequence is Option<Punctuated<T, P>>.

use m2_syn::{Lex, Span};

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

Implementations

impl<S, P> Punctuated<S, P>

pub fn new(first: S, punctuation: P, second: S) -> Self

Creates a sequence from the first two values and their punctuation.

pub fn from_pair(pair: SeparatedPair<S, P>) -> Self

Creates a two-value sequence from one punctuated pair.

pub fn from_pair_and_rest(pair: SeparatedPair<S, P>, rest: Vec<(P, S)>) -> Self

Creates a sequence from its first separated pair and any later punctuation-value pairs.

pub fn first(&self) -> &S

Returns the first value.

pub fn first_mut(&mut self) -> &mut S

Returns the first value mutably.

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

Borrows every punctuation-value pair following the first value.

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

Mutably borrows every punctuation-value pair following the first value.

pub fn into_parts(self) -> (SeparatedPair<S, P>, Vec<(P, S)>)

Separates the sequence into its first pair and any later pairs.

pub fn len(&self) -> usize

Returns the number of values, excluding punctuation.

pub const fn is_empty(&self) -> bool

Returns false; a punctuated sequence always contains at least two values.

pub fn token_len(&self) -> usize

Returns the number of values and punctuation tokens together.

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

Borrows the values without discarding or synthesizing punctuation.

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

Mutably borrows the values without discarding or synthesizing punctuation.

pub fn push(&mut self, punctuation: P, value: S)

Appends a real punctuation token and the value following it.

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

Maps the values while retaining every punctuation token unchanged.

pub fn try_map<T, Q, E>( self, map_value: impl FnMut(S) -> Result<T, E>, map_punct: impl FnMut(P) -> Result<Q, E>, ) -> Result<Punctuated<T, Q>, E>

Fallibly maps both values and punctuation while retaining their order.

Errors

Returns the first error produced by either mapping function.

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

impl<S, P> IntoIterator for Punctuated<S, P>

type Item = S

The type of the elements being iterated over.

type IntoIter = Chain<Once<S>, Map<Chain<Once<(P, S)>, IntoIter<(P, S)>>, fn((P, S)) -> 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, P> IntoIterator for &'a Punctuated<S, P>

type Item = &'a S

The type of the elements being iterated over.

type IntoIter = Chain<Once<&'a S>, Map<Chain<Once<&'a (P, S)>, Iter<'a, (P, S)>>, fn(&(P, S)) -> &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, P> IntoIterator for &'a mut Punctuated<S, P>

type Item = &'a mut S

The type of the elements being iterated over.

type IntoIter = Chain<Once<&'a mut S>, Map<Chain<Once<&'a mut (P, S)>, IterMut<'a, (P, S)>>, fn(&mut (P, S)) -> &mut S>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<S: Lex, P: Lex> Lex for Punctuated<S, P>

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

Appends this value’s token trees to output.

fn to_token_stream(&self) -> TokenStream

Emits this value into a fresh token stream.

fn to_m2(&self) -> String

Renders this value as normalized Macaulay2 source.

impl<S, P> Parse for Punctuated<S, P>

where S: Parse, P: Parse + Token,

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

Consumes this value from input.

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

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

Equality operator ==.

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

Inequality operator !=.

impl<T, P> PrettyTree for Punctuated<T, P>

where T: PrettyTree + Spanned, P: PrettyTree + Spanned,

fn pretty_tree(&self) -> PrettyNode

Builds the presentation node for this syntax value.

impl<S, P> Spanned for Punctuated<S, P>

where S: Spanned, (P, S): Spanned, Vec<(P, S)>: Spanned,

fn try_span(&self) -> Option<Span>

Returns the smallest span covering this value, when its constituents share one source snapshot.

fn span(&self) -> Span

Returns the smallest span covering this value.

fn expect_span(&self) -> Span

Returns this value’s span when one source snapshot covers it.

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