Enum Item 

pub enum Item<'a> {
    Comm(&'a str),
    Str(&'a str),
    Sym(&'a str),
    Punct(&'a str),
    Parens(Seq<'a>),
    Brackets(Seq<'a>),
    Braces(Seq<'a>),
    Prefixed {
        sigil: char,
        item: Box<Item<'a>>,
    },
    Run(Vec<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 (:).

Parens(Seq<'a>)

A parenthesis-wrapped sequence.

Brackets(Seq<'a>)

A bracket-wrapped sequence.

Braces(Seq<'a>)

A brace-wrapped sequence.

Prefixed

An item marked with a leading sigil (&, ., or #).

Fields

sigil: char

item: Box<Item<'a>>

Run(Vec<Item<'a>>)

A run: two or more atoms written with no whitespace between them, so they form one chain item (Main.A.S, f(x), (f x).1, 3.14). Members are in written order; none is itself a Run, a Punct, or a Comm (a punct or comment ends a run). A lone atom is never wrapped in a Run.

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> Eq for Item<'a>

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> StructuralPartialEq for Item<'a>