Struct Group 

pub struct Group<D, I>
where
    D: Delimiter,
    I: Parse,
{ /* private fields */ }

A Group represents a delimited item. Group has two Generic types:

• D is the delimiter tokens around the item, it has to a type that implements tokens::Delimiter.
• I is the type of item inside the delimiters, it has to implement Parse.

    let buffer = "(\"Hello, World\")".to_owned();
    let mut buffer = CharStream::new(buffer).build();

    let value = Group::<tokens::Paren, StringValue>::parse(&mut buffer);
    assert!(value.is_ok());

    let buffer = "[0, 1, 2]".to_owned();
    let mut buffer = CharStream::new(buffer).build();

    let value = Group::<tokens::Bracket, List<Number, tokens::Comma>>::parse(&mut buffer);
    assert!(value.is_ok());

Trait Implementations

impl<D, I> Clone for Group<D, I>

where D: Delimiter + Clone, I: Parse + Clone,

fn clone(&self) -> Group<D, I>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D, I> Debug for Group<D, I>

where D: Delimiter, I: Parse + Debug,

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

Formats the value using the given formatter.

impl<T, D, I> From<Group<D, I>> for Vec<T>

where Vec<T>: From<I>, D: Delimiter, I: Parse,

fn from(group: Group<D, I>) -> Self

Converts to this type from the input type.

impl<S, T, D, I> From<Group<D, I>> for HashMap<S, T>

where Vec<(S, T)>: From<I>, D: Delimiter, I: Parse, S: Eq + Hash,

fn from(group: Group<D, I>) -> Self

Converts to this type from the input type.

impl<D: Delimiter, T: Parse + IntoIterator<Item = I, IntoIter = Iter>, I, Iter: Iterator<Item = I>> IntoIterator for Group<D, T>

type Item = I

The type of the elements being iterated over.

type IntoIter = Iter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<D, I> Parse for Group<D, I>

where D: Delimiter, I: Parse,

fn parse(value: &mut CharStream) -> Result<Self, ParseError>

where Self: Sized,

fn span(&self) -> Span