Enum pomelo_lex::token::LexKind

pub enum LexKind {
    Whitespace,
    Comment {
        terminated: bool,
    },
    Eq,
    Colon,
    Semicolon,
    LParen,
    RParen,
    LBracket,
    RBracket,
    LBrace,
    RBrace,
    Pipe,
    Hash,
    Comma,
    Dot,
    Ellipsis,
    Underscore,
    ThickArrow,
    ThinArrow,
    Int,
    Word,
    Real,
    Char {
        terminated: bool,
    },
    String {
        terminated: bool,
    },
    Ident,
    Unknown,
}

Kinds of lexical tokens.

Variants

Whitespace

Any non-empty sequence of whitespace chars.

Comment

Fields

terminated: bool

Example: “(* this is a comment *)”.

Eq

=

Colon

:

Semicolon

;

LParen

(

RParen

)

LBracket

[

RBracket

]

LBrace

{

RBrace

}

Pipe

|

Hash

#

Comma

,

Dot

.

Ellipsis

...

Underscore

_

ThickArrow

=>

ThinArrow

->

Int

An integer constant (decimal or hexadecimal).

Word

An unsigned constant (decimal or hexadecimal).

Real

An real constant (with possible exponential part).

Char

Fields

terminated: bool

An char constant (e.g., #"a").

String

Fields

terminated: bool

An string constant (e.g., "abc").

Ident

Keyword or (symbolic or alphanumeric) identifier.

Unknown

Unknown character.

Implementations

impl LexKind

pub fn from_char(c: char) -> Option<Self>

Returns Some(kind) if c matches a single character token, otherwise None.

Trait Implementations

impl Clone for LexKind

fn clone(&self) -> LexKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LexKind

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

Formats the value using the given formatter.

impl Hash for LexKind

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 PartialEq<LexKind> for LexKind

fn eq(&self, other: &LexKind) -> 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 Copy for LexKind

impl Eq for LexKind

impl StructuralEq for LexKind

impl StructuralPartialEq for LexKind