Struct Punctuated 

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

A nonempty sequence of syntax values separated by typed punctuation.

Every separator is stored as its actual token, including its source span. The first value is mandatory; optional or empty grammar positions belong in the element type, such as Option<T> or a syntax enum containing an empty variant, 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, rest: Vec<(P, S)>) -> Self

Creates a sequence from its first value and remaining punctuation-value pairs.

pub fn from_single(value: S) -> Self

Creates a sequence containing exactly one value.

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

Creates a two-value sequence from one punctuated pair.

pub fn first(&self) -> &S

Returns the first value.

Examples found in repository

examples/type_inference.rs (line 288)

fn infer(source: &str, context: &DemoRegistry) -> Result<DemoFact, ParseError> {
    let file = parse_file(source)?;
    let expression = match file.cells[0].content.pack.first() {
        Component::Expr(expression) => expression.as_ref(),
        Component::Empty(_) => panic!("expected an expression component"),
    };
    Ok(TypeChecker {
        context,
        results: Vec::new(),
    }
    .infer(expression))
}

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

Returns the first value mutably.

pub fn rest(&self) -> &[(P, S)]

Returns the punctuation-value pairs following the first value.

pub fn rest_mut(&mut self) -> &mut [(P, S)]

Returns the punctuation-value pairs following the first value mutably.

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

Separates the sequence into its first value and remaining 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 its first value.

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.

Examples found in repository

examples/type_inference.rs (line 73)

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

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.

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<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<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<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, 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>