Enum Item 

pub enum Item<'a> {
    Comm(&'a str),
    Str(&'a str),
    Sym(&'a str),
    Punct(&'a str),
    Tuple(Seq<'a>),
    List(Seq<'a>),
    Block(Seq<'a>),
    Prefixed {
        sigil: char,
        item: Box<Item<'a>>,
    },
}

A single visually-atomic entity in a chain (<item> in the spec).

Variants

Comm(&'a str)

A comment, stored raw including its // or /* */ delimiters.

Str(&'a str)

A string literal; the inner slice, between the quotes, undecoded (escapes are validated but not expanded — see the crate open note).

Sym(&'a str)

A symbol: a maximal run of symchars (identifier, number, operator, …).

Punct(&'a str)

Punctuation: a maximal run of punctchars standing between items (:).

Tuple(Seq<'a>)

A parenthesis-wrapped sequence.

List(Seq<'a>)

A bracket-wrapped sequence.

Block(Seq<'a>)

A brace-wrapped sequence.

Prefixed

An item marked with a leading sigil (& is the only one so far).

Fields

sigil: char

item: Box<Item<'a>>

Trait Implementations

impl<'a> Clone for Item<'a>

fn clone(&self) -> Item<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Item<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Item<'a>

fn eq(&self, other: &Item<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Eq for Item<'a>

impl<'a> StructuralPartialEq for Item<'a>