Enum FSharpElementType 

pub enum FSharpElementType {
    Root,
    Expression,
    Whitespace,
    Newline,
    Identifier,
    IntegerLiteral,
    FloatLiteral,
    StringLiteral,
    CharLiteral,
    BooleanLiteral,
    UnitLiteral,
    Literal,
    MatchCase,
    WildcardPattern,
    IdentifierPattern,
    TuplePattern,
    ListPattern,
    ActivePattern,
    Pattern,
    Lambda,
    Parenthesized,
    List,
    Record,
    Application,
    Let,
    Rec,
    And,
    In,
    If,
    Then,
    Else,
    Elif,
    Match,
    With,
    When,
    Function,
    Fun,
    Type,
    Val,
    Mutable,
    Of,
    As,
    Module,
    Namespace,
    Open,
    Try,
    Finally,
    Exception,
    Raise,
    Failwith,
    For,
    To,
    Downto,
    Do,
    Done,
    While,
    Yield,
    Return,
    Class,
    Interface,
    Inherit,
    Abstract,
    Override,
    Default,
    Member,
    Static,
    New,
    Lazy,
    Async,
    Seq,
    Use,
    Begin,
    End,
    Struct,
    Sig,
    True,
    False,
    Null,
    Or,
    Public,
    Private,
    Internal,
    Inline,
    Extern,
    Upcast,
    Downcast,
    Assert,
    Global,
    Base,
    This,
    Void,
    Delegate,
    Select,
    Obj,
    Unit,
    Int,
    Float,
    String,
    Bool,
    Char,
    Byte,
    SByte,
    Int16,
    UInt16,
    Int32,
    UInt32,
    Int64,
    UInt64,
    NativeInt,
    UNativeInt,
    Decimal,
    BigInt,
    Plus,
    Minus,
    Star,
    Slash,
    Percent,
    StarStar,
    Equal,
    NotEqual,
    LessThan,
    LessEqual,
    GreaterThan,
    GreaterEqual,
    AndAnd,
    OrOr,
    Not,
    BitwiseAnd,
    BitwiseOr,
    BitwiseXor,
    BitwiseNot,
    LeftShift,
    RightShift,
    Arrow,
    DoubleArrow,
    Pipe,
    PipeRight,
    DoublePipe,
    Cons,
    At,
    Compose,
    ComposeBack,
    Dollar,
    LogicalAnd,
    LogicalOr,
    Ampersand,
    Caret,
    Tilde,
    Less,
    Greater,
    PipeGreater,
    Exclamation,
    ColonEqual,
    LArrow,
    PlusPlus,
    MinusMinus,
    LeftParen,
    RightParen,
    LeftBracket,
    RightBracket,
    LeftArrayBracket,
    RightArrayBracket,
    LeftBracketBar,
    RightBracketBar,
    LeftBracketAngle,
    RightBracketAngle,
    LeftBrace,
    RightBrace,
    LeftAngle,
    RightAngle,
    Comma,
    Semicolon,
    Colon,
    DoubleColon,
    Dot,
    DotDot,
    Question,
    Underscore,
    Apostrophe,
    Backtick,
    Hash,
    LineComment,
    BlockComment,
    Error,
    Eof,
}

F# element types

Variants

Root

Root node

Expression

Expression

Whitespace

Whitespace

Newline

Newline

Identifier

Identifier

IntegerLiteral

Integer literal

FloatLiteral

Float literal

StringLiteral

String literal

CharLiteral

Character literal

BooleanLiteral

Boolean literal

UnitLiteral

Unit literal

Literal

Literal

MatchCase

Match case

WildcardPattern

Wildcard pattern

IdentifierPattern

Identifier pattern

TuplePattern

Tuple pattern

ListPattern

List pattern

ActivePattern

Active pattern

Pattern

Pattern

Lambda

Lambda expression

Parenthesized

Parenthesized expression

List

List expression

Record

Record expression

Application

Function application

Let

The ‘let’ keyword

Rec

The ‘rec’ keyword

And

The ‘and’ keyword

In

The ‘in’ keyword

If

The ‘if’ keyword

Then

The ‘then’ keyword

Else

The ‘else’ keyword

Elif

The ‘elif’ keyword

Match

The ‘match’ keyword

With

The ‘with’ keyword

When

The ‘when’ keyword

Function

The ‘function’ keyword

Fun

The ‘fun’ keyword

Type

The ‘type’ keyword

Val

The ‘val’ keyword

Mutable

The ‘mutable’ keyword

Of

The ‘of’ keyword

As

The ‘as’ keyword

Module

The ‘module’ keyword

Namespace

The ‘namespace’ keyword

Open

The ‘open’ keyword

Try

The ‘try’ keyword

Finally

The ‘finally’ keyword

Exception

The ‘exception’ keyword

Raise

The ‘raise’ keyword

Failwith

The ‘failwith’ keyword

For

The ‘for’ keyword

To

The ‘to’ keyword

Downto

The ‘downto’ keyword

Do

The ‘do’ keyword

Done

The ‘done’ keyword

While

The ‘while’ keyword

Yield

The ‘yield’ keyword

Return

The ‘return’ keyword

Class

The ‘class’ keyword

Interface

The ‘interface’ keyword

Inherit

The ‘inherit’ keyword

Abstract

The ‘abstract’ keyword

Override

The ‘override’ keyword

Default

The ‘default’ keyword

Member

The ‘member’ keyword

Static

The ‘static’ keyword

New

The ‘new’ keyword

Lazy

The ‘lazy’ keyword

Async

The ‘async’ keyword

Seq

The ‘seq’ keyword

Use

The ‘use’ keyword

Begin

The ‘begin’ keyword

End

The ‘end’ keyword

Struct

The ‘struct’ keyword

Sig

The ‘sig’ keyword

True

The ‘true’ keyword

False

The ‘false’ keyword

Null

The ‘null’ keyword

Or

The ‘or’ keyword

Public

The ‘public’ keyword

Private

The ‘private’ keyword

Internal

The ‘internal’ keyword

Inline

The ‘inline’ keyword

Extern

The ‘extern’ keyword

Upcast

The ‘upcast’ keyword

Downcast

The ‘downcast’ keyword

Assert

The ‘assert’ keyword

Global

The ‘global’ keyword

Base

The ‘base’ keyword

This

The ‘this’ keyword

Void

The ‘void’ keyword

Delegate

The ‘delegate’ keyword

Select

The ‘select’ keyword

Obj

The ‘obj’ keyword

Unit

The ‘unit’ keyword

Int

The ‘int’ keyword

Float

The ‘float’ keyword

String

The ‘string’ keyword

Bool

The ‘bool’ keyword

Char

The ‘char’ keyword

Byte

The ‘byte’ keyword

SByte

The ‘sbyte’ keyword

Int16

The ‘int16’ keyword

UInt16

The ‘uint16’ keyword

Int32

The ‘int32’ keyword

UInt32

The ‘uint32’ keyword

Int64

The ‘int64’ keyword

UInt64

The ‘uint64’ keyword

NativeInt

The ‘nativeint’ keyword

UNativeInt

The ‘unativeint’ keyword

Decimal

The ‘decimal’ keyword

BigInt

The ‘bigint’ keyword

Plus

The ‘+’ operator

Minus

The ‘-’ operator

Star

The ‘*’ operator

Slash

The ‘/’ operator

Percent

The ‘%’ operator

StarStar

The ‘**’ operator

Equal

The ‘=’ operator

NotEqual

The ‘<>’ operator

LessThan

The ‘<’ operator

LessEqual

The ‘<=’ operator

GreaterThan

The ‘>’ operator

GreaterEqual

The ‘>=’ operator

AndAnd

The ‘&&’ operator

OrOr

The ‘||’ operator

Not

The ‘not’ operator

BitwiseAnd

The ‘&&&’ operator

BitwiseOr

The ‘|||’ operator

BitwiseXor

The ‘^^^’ operator

BitwiseNot

The ‘~~~’ operator

LeftShift

The ‘<<<’ operator

RightShift

The ‘>>>’ operator

Arrow

The ‘->’ operator

DoubleArrow

The ‘=>’ operator

Pipe

The ‘|’ operator

PipeRight

The ‘|>’ operator

DoublePipe

The ‘||’ operator

Cons

The ‘::’ operator

At

The ‘@’ operator

Compose

The ‘>>’ operator

ComposeBack

The ‘<<’ operator

Dollar

The ‘$’ operator

LogicalAnd

The ‘&&’ logical operator

LogicalOr

The ‘||’ logical operator

Ampersand

The ‘&’ operator

Caret

The ‘^’ operator

Tilde

The ‘~’ operator

Less

The ‘<’ operator

Greater

The ‘>’ operator

PipeGreater

The ‘|>’ operator

Exclamation

The ‘!’ operator

ColonEqual

The ‘:=’ operator

LArrow

The ‘<-’ operator

PlusPlus

The ‘++’ operator

MinusMinus

The ‘–’ operator

LeftParen

The ‘(’ delimiter

RightParen

The ‘)’ delimiter

LeftBracket

The ‘[’ delimiter

RightBracket

The ‘]’ delimiter

LeftArrayBracket

The ‘[|’ delimiter

RightArrayBracket

The ‘|]’ delimiter

LeftBracketBar

The ‘[<’ delimiter

RightBracketBar

The ‘>]’ delimiter

LeftBracketAngle

The ‘[ <’ delimiter

RightBracketAngle

The ‘> ]’ delimiter

LeftBrace

The ‘{’ delimiter

RightBrace

The ‘}’ delimiter

LeftAngle

The ‘<’ delimiter

RightAngle

The ‘>’ delimiter

Comma

The ‘,’ punctuation

Semicolon

The ‘;’ punctuation

Colon

The ‘:’ punctuation

DoubleColon

The ‘::’ punctuation

Dot

The ‘.’ punctuation

DotDot

The ‘..’ punctuation

Question

The ‘?’ punctuation

Underscore

The ‘_’ punctuation

Apostrophe

The ‘’’ punctuation

Backtick

The ‘`’ punctuation

Hash

The ‘#’ punctuation

LineComment

Line comment

BlockComment

Block comment

Error

Error

Eof

End of file

Implementations

impl FSharpElementType

pub fn is_keyword(&self) -> bool

Checks if it is a keyword

Trait Implementations

impl Clone for FSharpElementType

fn clone(&self) -> FSharpElementType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FSharpElementType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FSharpElementType

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl ElementType for FSharpElementType

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 From<FSharpTokenType> for FSharpElementType

fn from(token: FSharpTokenType) -> Self

Converts to this type from the input type.

impl Hash for FSharpElementType

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 FSharpElementType

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for FSharpElementType

impl Eq for FSharpElementType

impl StructuralPartialEq for FSharpElementType