Enum Ast

pub enum Ast {
    Block(BTreeMap<i64, Ast>),
    String(String),
    Int(Decimal),
    Identifier(String),
    BinaryOp {
        op: String,
        left: Box<Ast>,
        right: Box<Ast>,
    },
    Set {
        id: Box<Ast>,
        expr: Box<Ast>,
    },
    FunctionDefinition {
        id: String,
        params: Vec<(String, String)>,
        body: Box<Ast>,
    },
    FunctionCall {
        id: String,
        args: Vec<Ast>,
    },
    Array(Vec<Ast>),
    ArrayCall {
        id: String,
        k: Box<Ast>,
    },
    Bool(bool),
    If {
        condition: Box<Ast>,
        block: Box<Ast>,
    },
}

Abstract syntax tree type Should have tree structure but I’m stupid so not now

Variants

Block(BTreeMap<i64, Ast>)

Code block (This is also used on the top domain / parent tree)

Tuple Fields

0: BTreeMap<i64, Ast>

Map of the block

String(String)

String data type

Int(Decimal)

Decimal data type (a bit of misleading name)

Identifier(String)

All identifiers (a-Z). Used in function name, variable name, etc.

BinaryOp

Binary operation (Can be nested)

Example

let a: Ast = Ast::BinaryOp {
    op: "+".to_string(),
    left: Box::new(Ast::Int(dec!(0.1))),
    right: Box::new(Ast::Int(dec!(0.2))),
};

Fields

op: String

Operator

left: Box<Ast>

Left expression

right: Box<Ast>

Right expression

Set

Set expression (id = expr)

Fields

id: Box<Ast>

Identifier to set value to

expr: Box<Ast>

Expression of value to set

FunctionDefinition

Define function

Fields

id: String

Function name

params: Vec<(String, String)>

Function parameter (Params name, Params type)

body: Box<Ast>

Code of the function (Ast::Block)

FunctionCall

Function call

Fields

id: String

Name of function to call

args: Vec<Ast>

Argument given

Array(Vec<Ast>)

Array (is a Vector in Array clothing)

Tuple Fields

0: Vec<Ast>

Vector to set

ArrayCall

Accessing array field

Fields

id: String

Ast::Identifier of the array name

k: Box<Ast>

Where to access (wrapped in Box)

Bool(bool)

Boolean data type

Tuple Fields

0: bool

Bool to create

If

If structure

Fields

condition: Box<Ast>

Condition for the block to be run

block: Box<Ast>

The code block that will run if condition evaluated to true

Implementations

impl Ast

pub fn parse_code(block: &str) -> Result<Ast>

Parse code from string Return Err if can’t parse, else Return Result<Ast>

Example

Parsing identifier

assert_eq!(Ast::parse_code("x").unwrap(), Ast::Block(BTreeMap::from([(1, Ast::Identifier("x".to_string()))])));

Parsing set

assert_eq!(Ast::parse_code("x = 0;").unwrap(), Ast::Block(BTreeMap::from([(1, Ast::Set {id: Box::new(Ast::Identifier("x".to_string())), expr: Box::new(Ast::Int(dec!(0)))})])));
assert_eq!(Ast::parse_code("x").unwrap(), Ast::Block(BTreeMap::from([(1, Ast::Identifier("x".to_string()))])));

Trait Implementations

impl Clone for Ast

fn clone(&self) -> Ast

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ast

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

Formats the value using the given formatter.

impl Display for Ast

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

Formats the value using the given formatter.

impl PartialEq for Ast

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

Tests for self and other values to be equal, and is used by ==.

const 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 Eq for Ast

impl StructuralPartialEq for Ast