Enum Dispatch 

#[repr(u8)]
pub enum Dispatch {
    ERR = 0,
    WHS = 1,
    EXL = 2,
    QOT = 3,
    IDT = 4,
    DOL = 5,
    HAS = 6,
    PRC = 7,
    AMP = 8,
    PNO = 9,
    PNC = 10,
    MUL = 11,
    PLS = 12,
    COM = 13,
    MIN = 14,
    PRD = 15,
    SLH = 16,
    ZER = 17,
    DIG = 18,
    COL = 19,
    SEM = 20,
    LSS = 21,
    EQL = 22,
    MOR = 23,
    QST = 24,
    AT_ = 25,
    BTO = 26,
    BSL = 27,
    BTC = 28,
    CRT = 29,
    TPL = 30,
    BEO = 31,
    PIP = 32,
    BEC = 33,
    TLD = 34,
    UNI = 35,
}

Every handler a byte coming in could be mapped to

Variants

ERR = 0

Error token

WHS = 1

Whitespace

EXL = 2

Exclamation

QOT = 3

Single ' or Double quote "

IDT = 4

ASCII letter or _

DOL = 5

Dollar sign $

HAS = 6

Hash #

PRC = 7

Percentage %

AMP = 8

Ampersand &

PNO = 9

Left paren (

PNC = 10

Right paren )

MUL = 11

Multiply *

PLS = 12

Plus +

COM = 13

Comma ,

MIN = 14

Minus -

PRD = 15

Dot .

SLH = 16

Slash /

ZER = 17

Zero 0

DIG = 18

Digit (1-9)

COL = 19

Colon :

SEM = 20

Semicolon ;

LSS = 21

Less than <`

EQL = 22

Equal =

MOR = 23

More than >

QST = 24

Question ?

AT_ = 25

At @

BTO = 26

Left bracket [

BSL = 27

Backslash \

BTC = 28

Right bracket ]

CRT = 29

^

TPL = 30

Tick `

BEO = 31

Left curly bracket {

PIP = 32

Pipe |

BEC = 33

Right curly bracket }

TLD = 34

Tilde ~

UNI = 35

Unicode range (non ASCII)

Trait Implementations

impl Clone for Dispatch

fn clone(&self) -> Dispatch

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Dispatch

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

Formats the value using the given formatter.

impl Hash for Dispatch

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 for Dispatch

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

impl Eq for Dispatch

impl StructuralPartialEq for Dispatch