Struct parsel::ast::Punctuated

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

Parses a given production repeatedly, separated by punctuation. Optional trailing punctuation is allowed, and the entire token stream must consist of interleaved representations of T and P. (Thus, this is generally only useful within a delimited group.)

let items: Punctuated<Lit, Token![,]> = parse_quote!(44, true, "str liter", 5.55,);
let items: Vec<Lit> = items.into_iter().collect();

assert_eq!(items, [
    Lit::from(44_u64),
    Lit::from(true),
    Lit::from("str liter"),
    Lit::try_from(5.55).unwrap(),
]);

Implementations

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

pub const fn new() -> Self

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

pub fn into_inner(self) -> Punctuated<T, P>

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

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

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

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

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

Methods from Deref<Target = Punctuated<T, P>>

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<&T>

Borrows the first element in this sequence.

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

Mutably borrows the first element in this sequence.

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

Borrows the last element in this sequence.

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

Mutably borrows the last element in this sequence.

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

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

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

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

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

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

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

Returns an iterator over the contents of this sequence as mutably borrowed 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 already have a trailing punctuation, or be empty.

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

Panics

Panics if the sequence is nonempty and does not already have a trailing punctuation.

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 pop_punct(&mut self) -> Option<P>

Removes the trailing punctuation from this punctuated sequence, or None if there isn’t any.

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

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.

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.

pub fn clear(&mut self)

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

Trait Implementations

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

fn as_mut(&mut self) -> &mut Punctuated<T, P>

Converts this type into a mutable reference of the (usually inferred) input type.

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

fn as_ref(&self) -> &Punctuated<T, P>

Converts this type into a shared reference of the (usually inferred) input type.

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

fn borrow(&self) -> &Punctuated<T, P>

Immutably borrows from an owned value.

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

fn borrow_mut(&mut self) -> &mut Punctuated<T, P>

Mutably borrows from an owned value.

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

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

type Target = Punctuated<T, P>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

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

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

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

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

Formats the value using the given formatter.

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

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

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

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.

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

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

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

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.

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

fn from(punctuated: Punctuated<T, P>) -> Self

Converts to this type from the input type.

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

fn from(inner: Punctuated<T, P>) -> Self

Converts to this type from the input type.

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

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

Creates a value from an iterator.

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

fn from_iter<I>(iter: I) -> Selfwhere I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<T, P> FromStr for Punctuated<T, P>where T: Parse, P: Parse,

type Err = Error

The associated error which can be returned from parsing.

fn from_str(string: &str) -> Result<Self>

Parses a string s to return a value of this type.

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

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

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.

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

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

fn parse(input: ParseStream<'_>) -> Result<Self>

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

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

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

Write self to the given TokenStream.

fn to_token_stream(&self) -> TokenStream

Convert self directly into a TokenStream object.

fn into_token_stream(self) -> TokenStreamwhere Self: Sized,

Convert self directly into a TokenStream object.

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

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

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