Enum DHallElementType 

#[repr(u8)]
pub enum DHallElementType {
    Whitespace = 0,
    Newline = 1,
    Comment = 2,
    Identifier = 3,
    Number = 4,
    String = 5,
    If = 6,
    Then = 7,
    Else = 8,
    Let = 9,
    In = 10,
    Using = 11,
    As = 12,
    Merge = 13,
    Some = 14,
    None = 15,
    NaN = 16,
    Infinity = 17,
    Type = 18,
    Kind = 19,
    Sort = 20,
    Bool = 21,
    Natural = 22,
    Integer = 23,
    Double = 24,
    Text = 25,
    List = 26,
    Optional = 27,
    True = 28,
    False = 29,
    With = 30,
    Forall = 31,
    Assert = 32,
    Arrow = 33,
    FatArrow = 34,
    EqualEqual = 35,
    NotEqual = 36,
    And = 37,
    Or = 38,
    Append = 39,
    Combine = 40,
    CombineTypes = 41,
    Prefer = 42,
    Lambda = 43,
    LeftParen = 44,
    RightParen = 45,
    LeftBrace = 46,
    RightBrace = 47,
    LeftBracket = 48,
    RightBracket = 49,
    Comma = 50,
    Semicolon = 51,
    Dot = 52,
    Colon = 53,
    Equal = 54,
    Less = 55,
    Greater = 56,
    Plus = 57,
    Minus = 58,
    Star = 59,
    Slash = 60,
    Pipe = 61,
    At = 62,
    Hash = 63,
    Question = 64,
    Error = 65,
    Eof = 66,
    Root = 67,
    SourceFile = 68,
}

Element types for DHall AST.

Variants

Whitespace = 0

Whitespace.

Newline = 1

Newline.

Comment = 2

Comment.

Identifier = 3

Identifier.

Number = 4

Number.

String = 5

String literal.

If = 6

if

Then = 7

then

Else = 8

else

Let = 9

let

In = 10

in

Using = 11

using

As = 12

as

Merge = 13

merge

Some = 14

Some

None = 15

None

NaN = 16

NaN

Infinity = 17

Infinity

Type = 18

Type

Kind = 19

Kind

Sort = 20

Sort

Bool = 21

Bool

Natural = 22

Natural

Integer = 23

Integer

Double = 24

Double

Text = 25

Text

List = 26

List

Optional = 27

Optional

True = 28

True

False = 29

False

With = 30

with

Forall = 31

forall or ∀

Assert = 32

assert

Arrow = 33

-> or →

FatArrow = 34

=> or ⇒

EqualEqual = 35

==

NotEqual = 36

!=

And = 37

&&

Or = 38

||

Append = 39

++

Combine = 40

//

CombineTypes = 41

//\\

Prefer = 42

///

Lambda = 43

\ or λ

LeftParen = 44

(

RightParen = 45

)

LeftBrace = 46

{

RightBrace = 47

}

LeftBracket = 48

[

RightBracket = 49

]

Comma = 50

,

Semicolon = 51

;

Dot = 52

.

Colon = 53

:

Equal = 54

=

Less = 55

<

Greater = 56

>

Plus = 57

+

Minus = 58

-

Star = 59

*

Slash = 60

/

Pipe = 61

|

At = 62

@

Hash = 63

#

Question = 64

?

Error = 65

Error element.

Eof = 66

End of file.

Root = 67

Root node.

SourceFile = 68

Source file node.

Implementations

impl DHallElementType

pub fn is_keyword(&self) -> bool

Returns true if the element type is a keyword.

Trait Implementations

impl Clone for DHallElementType

fn clone(&self) -> DHallElementType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DHallElementType

impl Debug for DHallElementType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DHallElementType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl ElementType for DHallElementType

type Role = UniversalElementRole

The associated role type for this element kind.

fn role(&self) -> Self::Role

Returns the general syntactic role of this element.

fn is_role(&self, role: Self::Role) -> bool

Returns true if this element matches the specified language-specific role.

fn is_universal(&self, role: UniversalElementRole) -> bool

Returns true if this element matches the specified universal role.

fn is_root(&self) -> bool

Returns true if this element represents the root of the parsed tree.

fn is_error(&self) -> bool

Returns true if this element represents an error condition.

impl Eq for DHallElementType

impl From<DHallTokenType> for DHallElementType

fn from(token: DHallTokenType) -> Self

Converts to this type from the input type.

impl Hash for DHallElementType

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 DHallElementType

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DHallElementType