Struct syn::punctuated::Punctuated

pub struct Punctuated<T, P> { /* fields omitted */ }

A punctuated sequence of syntax tree nodes of type T separated by punctuation of type P.

Refer to the module documentation for details about punctuated sequences.

Methods

impl<T, P> Punctuated<T, P>

pub fn new() -> Punctuated<T, P>

Creates an empty punctuated sequence.

pub fn is_empty(&self) -> bool

Determines whether this punctuated sequence is empty, meaning it contains no syntax tree nodes or punctuation.

pub fn len(&self) -> usize

Returns the number of syntax tree nodes in this punctuated sequence.

This is the number of nodes of type T, not counting the punctuation of type P.

pub fn first(&self) -> Option<Pair<&T, &P>>

Borrows the first punctuated pair in this sequence.

pub fn last(&self) -> Option<Pair<&T, &P>>

Borrows the last punctuated pair in this sequence.

pub fn last_mut(&mut self) -> Option<Pair<&mut T, &mut P>>

Mutably borrows the last punctuated pair in this sequence.

Important traits for Iter<'a, T>

impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T;

pub fn iter(&self) -> Iter<T>

Returns an iterator over borrowed syntax tree nodes of type &T.

Important traits for IterMut<'a, T>

impl<'a, T> Iterator for IterMut<'a, T> type Item = &'a mut T;

pub fn iter_mut(&mut self) -> IterMut<T>

Returns an iterator over mutably borrowed syntax tree nodes of type &mut T.

Important traits for Pairs<'a, T, P>

impl<'a, T, P> Iterator for Pairs<'a, T, P> type Item = Pair<&'a T, &'a P>;

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

Returns an iterator over the contents of this sequence as borrowed punctuated pairs.

Important traits for PairsMut<'a, T, P>

impl<'a, T, P> Iterator for PairsMut<'a, T, P> type Item = Pair<&'a mut T, &'a mut P>;

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

Returns an iterator over the contents of this sequence as mutably borrowed punctuated pairs.

Important traits for IntoPairs<T, P>

impl<T, P> Iterator for IntoPairs<T, P> type Item = Pair<T, P>;

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

Returns an iterator over the contents of this sequence as owned punctuated pairs.

pub fn push_value(&mut self, value: T)

Appends a syntax tree node onto the end of this punctuated sequence. The sequence must previously have a trailing punctuation.

Use push instead if the punctuated sequence may or may not already have trailing punctuation.

Panics

Panics if the sequence does not already have a trailing punctuation when this method is called.

pub fn push_punct(&mut self, punctuation: P)

Appends a trailing punctuation onto the end of this punctuated sequence. The sequence must be non-empty and must not already have trailing punctuation.

Panics

Panics if the sequence is empty or already has a trailing punctuation.

pub fn pop(&mut self) -> Option<Pair<T, P>>

Removes the last punctuated pair from this sequence, or None if the sequence is empty.

pub fn trailing_punct(&self) -> bool

Determines whether this punctuated sequence ends with a trailing punctuation.

pub fn empty_or_trailing(&self) -> bool

Returns true if either this Punctuated is empty, or it has a trailing punctuation.

Equivalent to punctuated.is_empty() || punctuated.trailing_punct().

impl<T, P> Punctuated<T, P> where
    P: Default, 

pub fn push(&mut self, value: T)

Appends a syntax tree node onto the end of this punctuated sequence.

If there is not a trailing punctuation in this sequence when this method is called, the default value of punctuation type P is inserted before the given value of type T.

pub fn insert(&mut self, index: usize, value: T)

Inserts an element at position index.

Panics

Panics if index is greater than the number of elements previously in this punctuated sequence.

impl<T, P> Punctuated<T, P> where
    T: Synom,
    P: Synom, 

pub fn parse_separated(input: Cursor) -> PResult<Self>

Parse zero or more syntax tree nodes with punctuation in between and no trailing punctuation.

pub fn parse_separated_nonempty(input: Cursor) -> PResult<Self>

Parse one or more syntax tree nodes with punctuation in bewteen and no trailing punctuation. allowing trailing punctuation.

pub fn parse_terminated(input: Cursor) -> PResult<Self>

Parse zero or more syntax tree nodes with punctuation in between and optional trailing punctuation.

pub fn parse_terminated_nonempty(input: Cursor) -> PResult<Self>

Parse one or more syntax tree nodes with punctuation in between and optional trailing punctuation.

impl<T, P> Punctuated<T, P> where
    P: Synom, 

pub fn parse_separated_with(
    input: Cursor,
    parse: fn(_: Cursor) -> PResult<T>
) -> PResult<Self>

Parse zero or more syntax tree nodes using the given parser with punctuation in between and no trailing punctuation.

pub fn parse_separated_nonempty_with(
    input: Cursor,
    parse: fn(_: Cursor) -> PResult<T>
) -> PResult<Self>

Parse one or more syntax tree nodes using the given parser with punctuation in between and no trailing punctuation.

pub fn parse_terminated_with(
    input: Cursor,
    parse: fn(_: Cursor) -> PResult<T>
) -> PResult<Self>

Parse zero or more syntax tree nodes using the given parser with punctuation in between and optional trailing punctuation.

pub fn parse_terminated_nonempty_with(
    input: Cursor,
    parse: fn(_: Cursor) -> PResult<T>
) -> PResult<Self>

Parse one or more syntax tree nodes using the given parser with punctuation in between and optional trailing punctuation.

Trait Implementations

impl<T, P> ToTokens for Punctuated<T, P> where
    T: ToTokens,
    P: ToTokens, 

fn to_tokens(&self, tokens: &mut Tokens)

Write self to the given Tokens.

fn into_tokens(self) -> Tokens

Convert self directly into a Tokens object.

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

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

fn eq(&self, __arg_0: &Punctuated<T, P>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &Punctuated<T, P>) -> bool

This method tests for !=.

impl<T: Hash, P: Hash> Hash for Punctuated<T, P>

fn hash<__HTP: Hasher>(&self, __arg_0: &mut __HTP)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<T: Clone, P: Clone> 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> Debug for Punctuated<T, P>

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

Formats the value using the given formatter.

impl<T, P> FromIterator<T> for Punctuated<T, P> where
    P: Default, 

fn from_iter<I: IntoIterator<Item = T>>(i: I) -> Self

Creates a value from an iterator.

impl<T, P> Extend<T> for Punctuated<T, P> where
    P: Default, 

fn extend<I: IntoIterator<Item = T>>(&mut self, i: I)

Extends a collection with the contents of an iterator.

impl<T, P> FromIterator<Pair<T, P>> for Punctuated<T, P>

fn from_iter<I: IntoIterator<Item = Pair<T, P>>>(i: I) -> Self

Creates a value from an iterator.

impl<T, P> Extend<Pair<T, P>> for Punctuated<T, P>

fn extend<I: IntoIterator<Item = Pair<T, P>>>(&mut self, i: I)

Extends a collection with the contents of an iterator.

impl<T, P> 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.

impl<'a, T, P> IntoIterator for &'a Punctuated<T, P>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, P> IntoIterator for &'a mut Punctuated<T, P>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

fn default() -> Self

Returns the "default value" for a type.

impl<T, P> Index<usize> for Punctuated<T, P>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, P> IndexMut<usize> for Punctuated<T, P>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.