Struct parsel::ast::Separated

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

Parses a given production repeatedly, separated by punctuation. Trailing punctuation is not allowed, and the production must appear at least once in the input. Parsing stops gracefully once there are no more separators left at the head of the input stream.

It can’t be Default because that would mean an empty sequence.

use parsel::Result;
use parsel::ast::{ident, LitInt, Ident, Separated, Many};
use parsel::ast::token::{Add, Colon2, Comma};

let mut sum: Separated<LitInt, Add> = parsel::parse_quote! {
    1 + 2 + 4 + 8 + 16 + 32
};
sum.push_value(LitInt::from(64));

assert_eq!(sum.to_string(), "1 + 2 + 4 + 8 + 16 + 32 + 64");

let good_short: Separated<Ident, Colon2> = parsel::parse_quote!(one);
let good_short: Vec<_> = good_short.into_iter().collect();
let expected_short = vec![ident("one")];
assert_eq!(good_short, expected_short);

let good_long: Separated<Ident, Colon2> = parsel::parse_quote! {
    root::module::Item
};
let good_long: Vec<_> = good_long.into_iter().collect();
let expected_long: Many<Ident> = parsel::parse_quote!(root module Item);
let expected_long: Vec<_> = expected_long.into_iter().collect();
assert_eq!(good_long, expected_long);

let bad_trailing: Result<Separated<Ident, Colon2>> = parsel::parse_str(r"
    root::module::Item::
");
assert!(bad_trailing.is_err());

let bad_empty: Result<Separated<Ident, Colon2>> = parsel::parse_str("");
assert!(bad_empty.is_err());

Implementations

impl<T, P> Separated<T, P>

pub fn len(&self) -> NonZeroUsize

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

pub fn first(&self) -> &T

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

pub fn last(&self) -> &T

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

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

insert() is allowed because it doesn’t ever make the sequence empty, nor does it add trailing punctuation, so it doesn’t violate the invariants of the type.

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

push() is allowed because it doesn’t ever make the sequence empty, nor does it add trailing punctuation, so it doesn’t violate the invariants of the type.

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

push_value() is allowed because it doesn’t ever make the sequence empty, nor does it add trailing punctuation, so it doesn’t violate the invariants of the type.

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>

pub fn into_first_rest(self) -> (T, Vec<(P, T)>)

Returns the first value and the remaining (punctuation, value) pairs.

let singleton: Separated<LitInt, Comma> = parsel::parse_quote!(137);
let (first, rest) = singleton.into_first_rest();
assert_eq!(first, LitInt::from(137));
assert_eq!(rest, []);

let triplet: Separated<LitInt, Comma> = parsel::parse_quote!(731, 813, 139);
let (first, rest) = triplet.into_first_rest();
assert_eq!(first, LitInt::from(731));
assert_eq!(rest, [
    (Comma::default(), LitInt::from(813)),
    (Comma::default(), LitInt::from(139)),
]);

pub fn into_last_rest(self) -> (T, Vec<(T, P)>)

Returns the last value and the preceding (value, punctuation) pairs.

let singleton: Separated<LitChar, Semi> = parsel::parse_quote!('W');
let (last, rest) = singleton.into_last_rest();
assert_eq!(last, LitChar::from('W'));
assert_eq!(rest, []);

let triplet: Separated<LitChar, Semi> = parsel::parse_quote!('"'; 'é'; '\'');
let (last, rest) = triplet.into_last_rest();
assert_eq!(last, LitChar::from('\''));
assert_eq!(rest, [
    (LitChar::from('"'), Semi::default()),
    (LitChar::from('é'), Semi::default()),
]);

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 last(&self) -> Option<&T>

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 pairs(&self) -> Pairs<'_, T, P>

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

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

Trait Implementations

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

See the documentation of impl Deref for Separated for why this can’t be AsMut.

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 Separated<T, P>

See the documentation of impl Deref for Separated for why this can’t be BorrowMut.

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

Immutably borrows from an owned value.

impl<T: Clone, P: Clone> Clone for Separated<T, P>

fn clone(&self) -> Separated<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 Separated<T, P>where
    T: Debug,
    P: Debug,

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

Formats the value using the given formatter.

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

It can’t be DerefMut, because then users could .pop() the last remaining item, resulting in an empty Separated. They could push a trailing separator, too, which also violates internal invariants.

type Target = Punctuated<T, P>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, P> Display for Separated<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<(P, T)> for Separated<T, P>

Extend<(P, T)> can be implemented because it never causes the sequence to become empty, nor does it add any trailing punctuation.

fn extend<I>(&mut self, iter: I)where
    I: IntoIterator<Item = (P, 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> Extend<T> for Separated<T, P>where
    P: Default,

Extend<Pair<T, P>> is not provided because it requires either an empty sequence or one with trailing punctuation.

FromIterator impls are missing because the input iterator could be empty.

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<Separated<T, P>> for Punctuated<T, P>

fn from(separated: Separated<T, P>) -> Self

Converts to this type from the input type.

impl<T, P> FromStr for Separated<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 Separated<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,

Feeds a slice of this type into the given Hasher.

impl<T, P> Index<usize> for Separated<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 Separated<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 Separated<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 Separated<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 Separated<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 Separated<T, P>where
    T: Parse,
    P: Parse,

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

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

fn eq(&self, other: &Separated<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 Separated<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) -> TokenStream

Convert self directly into a TokenStream object.

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

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.

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

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

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