Enum nyar_valkyrie::AST

pub enum AST {
    Program(Vec<AST>),
    Suite(Vec<AST>),
    EmptyStatement,
    ImportStatement {
        data: ImportStatement,
        annotations: Option<Box<AST>>,
    },
    IfStatement {
        pairs: Vec<(AST, AST)>,
        default: Option<Box<AST>>,
        annotations: Option<Box<AST>>,
    },
    LetBinding {
        symbol: Box<AST>,
        modifiers: Vec<String>,
        types: Box<AST>,
        annotations: Option<Box<AST>>,
    },
    Expression {
        base: Box<AST>,
        eos: bool,
        pos: Position,
        annotations: Option<Box<AST>>,
    },
    TypeExpression {
        base: Box<AST>,
        pos: Position,
        annotations: Option<Box<AST>>,
    },
    UnaryOperators {
        base: Box<AST>,
        prefix: Vec<String>,
        suffix: Vec<String>,
        pos: Position,
    },
    InfixOperators {
        o: String,
        lhs: Box<AST>,
        rhs: Box<AST>,
        pos: Position,
    },
    ListExpression(Vec<AST>),
    TupleExpression(Vec<AST>),
    SliceExpression {
        base: Box<AST>,
        list: Vec<AST>,
    },
    IndexExpression(IndexExpression),
    ApplyExpression {
        base: Box<AST>,
        types: Vec<AST>,
        args: Vec<AST>,
        kv_pairs: Vec<(AST, AST)>,
        pos: Position,
    },
    Symbol {
        name: String,
        scope: Vec<String>,
    },
    NumberLiteral {
        handler: String,
        data: String,
    },
    Number(Number),
    StringLiteral {
        handler: String,
        data: String,
    },
    String(String),
    CommentLiteral {
        handler: String,
        data: String,
    },
    Boolean(bool),
    None,
}

Variants

Program(Vec<AST>)

Suite(Vec<AST>)

EmptyStatement

• EmptyStatement: Skip

ImportStatement

• ImportStatement

Fields of ImportStatement

data: ImportStatementannotations: Option<Box<AST>>

IfStatement

Fields of IfStatement

pairs: Vec<(AST, AST)>default: Option<Box<AST>>annotations: Option<Box<AST>>

LetBinding

Fields of LetBinding

symbol: Box<AST>modifiers: Vec<String>types: Box<AST>annotations: Option<Box<AST>>

Expression

• Expression

Fields of Expression

base: Box<AST>eos: boolpos: Positionannotations: Option<Box<AST>>

TypeExpression

• Expression

Fields of TypeExpression

base: Box<AST>pos: Positionannotations: Option<Box<AST>>

UnaryOperators

• UnaryOperators
• base

Fields of UnaryOperators

base: Box<AST>prefix: Vec<String>suffix: Vec<String>pos: Position

InfixOperators

• InfixOperators

Fields of InfixOperators

o: Stringlhs: Box<AST>rhs: Box<AST>pos: Position

ListExpression(Vec<AST>)

TupleExpression(Vec<AST>)

SliceExpression

• SliceExpression the terms must IndexExpression

Fields of SliceExpression

base: Box<AST>list: Vec<AST>

IndexExpression(IndexExpression)

ApplyExpression

Fields of ApplyExpression

base: Box<AST>types: Vec<AST>args: Vec<AST>kv_pairs: Vec<(AST, AST)>pos: Position

Symbol

• Symbol

Fields of Symbol

name: Stringscope: Vec<String>

NumberLiteral

• Number: raw number represent

Fields of NumberLiteral

handler: Stringdata: String

Number(Number)

StringLiteral

Fields of StringLiteral

handler: Stringdata: String

String(String)

• String: raw string

CommentLiteral

• Comment: raw comment with handler

Fields of CommentLiteral

handler: Stringdata: String

Boolean(bool)

None

• None: It doesn't look like anything to me

Methods

impl AST

pub fn save(&self, path: &str) -> Result<(), Error>

pub fn load(path: &str) -> AST

pub fn set_base(self, replace: AST) -> AST

Trait Implementations

impl Clone for AST

fn clone(&self) -> AST

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AST

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AST

fn deserialize<__D>(
    __deserializer: __D
) -> Result<AST, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl PartialEq<AST> for AST

fn eq(&self, other: &AST) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &AST) -> bool

This method tests for !=.

impl Serialize for AST

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for AST