Enum skiff::ast::AstNode

pub enum AstNode {
    NumberNode(i64),
    BoolNode(bool),
    VarNode(String),
    LetNodeTopLevel(Identifier, Box<Ast>),
    LetNode(Identifier, Box<Ast>, Box<Ast>),
    IfNode(Vec<(Ast, Ast)>, Box<Ast>),
    BinOpNode(BinOp, Box<Ast>, Box<Ast>),
    FunCallNode(Box<Ast>, Vec<Ast>),
    LambdaNode(Vec<Identifier>, Box<Ast>),
    FunctionNode(String, Vec<Identifier>, Option<Type>, Box<Ast>),
    DataDeclarationNode(String, Vec<(String, Vec<Identifier>)>),
    DataLiteralNode(Discriminant, Vec<Box<Ast>>),
    MatchNode(Box<Ast>, Vec<(Pattern, Ast)>),
}

Variants

NumberNode(i64)

(val)

Tuple Fields of NumberNode

0: i64

BoolNode(bool)

(val)

Tuple Fields of BoolNode

0: bool

VarNode(String)

(val)

Tuple Fields of VarNode

0: String

LetNodeTopLevel(Identifier, Box<Ast>)

(id, expr)

Tuple Fields of LetNodeTopLevel

0: Identifier1: Box<Ast>

LetNode(Identifier, Box<Ast>, Box<Ast>)

(id, expr, body)

Tuple Fields of LetNode

0: Identifier1: Box<Ast>2: Box<Ast>

IfNode(Vec<(Ast, Ast)>, Box<Ast>)

(conditions_and_bodies, alternate)

Tuple Fields of IfNode

0: Vec<(Ast, Ast)>1: Box<Ast>

BinOpNode(BinOp, Box<Ast>, Box<Ast>)

(operator, operand1, operand2)

Tuple Fields of BinOpNode

0: BinOp1: Box<Ast>2: Box<Ast>

FunCallNode(Box<Ast>, Vec<Ast>)

(fun_value, arg_list)

Tuple Fields of FunCallNode

0: Box<Ast>1: Vec<Ast>

LambdaNode(Vec<Identifier>, Box<Ast>)

(param_list, body)

Tuple Fields of LambdaNode

0: Vec<Identifier>1: Box<Ast>

FunctionNode(String, Vec<Identifier>, Option<Type>, Box<Ast>)

(function_name, param_list, body)

Tuple Fields of FunctionNode

0: String1: Vec<Identifier>2: Option<Type>3: Box<Ast>

DataDeclarationNode(String, Vec<(String, Vec<Identifier>)>)

(data_name, data_Variants)

Tuple Fields of DataDeclarationNode

0: String1: Vec<(String, Vec<Identifier>)>

DataLiteralNode(Discriminant, Vec<Box<Ast>>)

(discriminant, values)

Tuple Fields of DataLiteralNode

0: Discriminant1: Vec<Box<Ast>>

MatchNode(Box<Ast>, Vec<(Pattern, Ast)>)

(expression_to_match, branches)

Tuple Fields of MatchNode

0: Box<Ast>1: Vec<(Pattern, Ast)>

Trait Implementations

impl Clone for AstNode

fn clone(&self) -> AstNode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AstNode

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

Formats the value using the given formatter.

impl Hash for AstNode

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, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<AstNode> for AstNode

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

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

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

This method tests for !=.

impl StructuralPartialEq for AstNode