# Struct syn::punctuated::Punctuated

source · [−]

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

Expand description

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.

## Implementations

source

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

source

#### pub const fn new() -> Self

Creates an empty punctuated sequence.

source

#### pub fn is_empty(&self) -> bool

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

source

#### 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`.

source

#### pub fn first(&self) -> Option<&T>

Borrows the first element in this sequence.

source

#### pub fn first_mut(&mut self) -> Option<&mut T>

Mutably borrows the first element in this sequence.

source

#### pub fn last(&self) -> Option<&T>

Borrows the last element in this sequence.

source

#### pub fn last_mut(&mut self) -> Option<&mut T>

Mutably borrows the last element in this sequence.

source

#### pub fn iter(&self) -> Iter<'_, T>ⓘNotable traits for Iter<'a, T>`impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T;`

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

source

#### pub fn iter_mut(&mut self) -> IterMut<'_, T>ⓘNotable traits for IterMut<'a, T>`impl<'a, T> Iterator for IterMut<'a, T> type Item = &'a mut T;`

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

source

#### pub fn pairs(&self) -> Pairs<'_, T, P>ⓘNotable traits for Pairs<'a, T, P>`impl<'a, T, P> Iterator for Pairs<'a, T, P> type Item = Pair<&'a T, &'a P>;`

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

source

#### pub fn pairs_mut(&mut self) -> PairsMut<'_, T, P>ⓘNotable 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>;`

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

source

#### pub fn into_pairs(self) -> IntoPairs<T, P>ⓘNotable traits for IntoPairs<T, P>`impl<T, P> Iterator for IntoPairs<T, P> type Item = Pair<T, P>;`

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

source

#### 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.

source

#### 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.

source

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

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

source

#### pub fn trailing_punct(&self) -> bool

Determines whether this punctuated sequence ends with a trailing punctuation.

source

#### 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()`.

source

#### pub fn push(&mut self, value: T) where
P: Default,

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`.

source

#### pub fn insert(&mut self, index: usize, value: T) where
P: Default,

Inserts an element at position `index`.

##### Panics

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

source

#### pub fn clear(&mut self)

Clears the sequence of all values and punctuation, making it empty.

source

#### pub fn parse_terminated(input: ParseStream<'_>) -> Result<Self> where
T: Parse,
P: Parse,

Parses zero or more occurrences of `T` separated by punctuation of type `P`, with optional trailing punctuation.

Parsing continues until the end of this parse stream. The entire content of this parse stream must consist of `T` and `P`.

This function is available only if Syn is built with the `"parsing"` feature.

source

#### pub fn parse_terminated_with(
input: ParseStream<'_>,
parser: fn(_: ParseStream<'_>) -> Result<T>
) -> Result<Self> where
P: Parse,

Parses zero or more occurrences of `T` using the given parse function, separated by punctuation of type `P`, with optional trailing punctuation.

Like `parse_terminated`, the entire content of this stream is expected to be parsed.

This function is available only if Syn is built with the `"parsing"` feature.

source

#### pub fn parse_separated_nonempty(input: ParseStream<'_>) -> Result<Self> where
T: Parse,
P: Token + Parse,

Parses one or more occurrences of `T` separated by punctuation of type `P`, not accepting trailing punctuation.

Parsing continues as long as punctuation `P` is present at the head of the stream. This method returns upon parsing a `T` and observing that it is not followed by a `P`, even if there are remaining tokens in the stream.

This function is available only if Syn is built with the `"parsing"` feature.

source

#### pub fn parse_separated_nonempty_with(
input: ParseStream<'_>,
parser: fn(_: ParseStream<'_>) -> Result<T>
) -> Result<Self> where
P: Token + Parse,

Parses one or more occurrences of `T` using the given parse function, separated by punctuation of type `P`, not accepting trailing punctuation.

Like `parse_separated_nonempty`, may complete early without parsing the entire content of this stream.

This function is available only if Syn is built with the `"parsing"` feature.

## Trait Implementations

source

### impl<T, P> Clone for Punctuated<T, P> where
T: Clone,
P: Clone,

source

#### fn clone(&self) -> Self

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from `source`. Read more

source

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

source

#### fn default() -> Self

Returns the “default value” for a type. Read more

source

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

source

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

Extends a collection with the contents of an iterator. Read more

source

#### fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (`extend_one`)

Extends a collection with exactly one element.

source

#### fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (`extend_one`)

Reserves capacity in a collection for the given number of additional elements. Read more

source

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

source

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

Extends a collection with the contents of an iterator. Read more

source

#### fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (`extend_one`)

Extends a collection with exactly one element.

source

#### fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (`extend_one`)

Reserves capacity in a collection for the given number of additional elements. Read more

source

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

source

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

Creates a value from an iterator. Read more

source

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

source

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

Creates a value from an iterator. Read more

source

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

#### type Output = T

The returned type after indexing.

source

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

Performs the indexing (`container[index]`) operation. Read more

source

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

source

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

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

source

### 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?

source

#### fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more

source

### 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?

source

#### fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more

source

### impl<T, P> IntoIterator for Punctuated<T, P>

#### type Item = T

The type of the elements being iterated over.

#### type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

source

#### fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more

source

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

source

#### fn to_tokens(&self, tokens: &mut TokenStream)

Write `self` to the given `TokenStream`. Read more

source

#### fn to_token_stream(&self) -> TokenStream

Convert `self` directly into a `TokenStream` object. Read more

source

#### fn into_token_stream(self) -> TokenStream

Convert `self` directly into a `TokenStream` object. Read more

## Auto Trait Implementations

### impl<T, P> RefUnwindSafe for Punctuated<T, P> where
P: RefUnwindSafe,
T: RefUnwindSafe,

### impl<T, P> Send for Punctuated<T, P> where
P: Send,
T: Send,

### impl<T, P> Sync for Punctuated<T, P> where
P: Sync,
T: Sync,

### impl<T, P> Unpin for Punctuated<T, P> where
P: Unpin,
T: Unpin,

### impl<T, P> UnwindSafe for Punctuated<T, P> where
P: UnwindSafe,
T: UnwindSafe,

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

### impl<T> From<T> for T

const: unstable · source

#### fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T> Spanned for T where
T: Spanned + ?Sized,

source

#### fn span(&self) -> Span

Returns a `Span` covering the complete contents of this syntax tree node, or `Span::call_site()` if this node is empty. Read more

source

### impl<T> ToOwned for T where
T: Clone,

#### type Owned = T

The resulting type after obtaining ownership.

source

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.