ralix 0.2.0

A simple, type-safe, tree walking interpreter
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use std::path::PathBuf;

use serde::Serialize;

use crate::{
    Literal,
    expressions::{
        ElseConsequence, FunctionParameter, HashMapItem, Identifier, IfConsequence, ImportedItem,
    },
    statements::Binding,
    types::{Type, TypeVarId},
};

pub mod expressions;
mod impls;
pub mod statements;
pub mod types;

#[derive(Debug, Clone, Serialize, PartialEq)]
pub enum Statement {
    Expression(Expression),
    Return(Option<Expression>),

    Binding(Binding),

    Assign {
        left: Expression,
        value: Expression,
    },

    Alias {
        ident: Identifier,
        ty: Type,
    },

    Get {
        module_name: Identifier,
        path_names: Vec<Identifier>,
        file_module_path: PathBuf,
        imported_items: Vec<ImportedItem>,
    },

    Out(Box<Statement>),
}

#[derive(Debug, Clone, Serialize, PartialEq)]
pub enum Expression {
    Identifier(expressions::Identifier),
    Integer(i64),
    Float(f64),
    Boolean(bool),
    String(Literal),
    Char(char),
    Null,
    TypeOf(Box<Expression>),
    Type(Type),
    Try(Box<Expression>),

    Infix {
        left: Box<Expression>,
        operator: expressions::InfixOperator,
        right: Box<Expression>,
    },

    Prefix {
        operator: expressions::PrefixOperator,
        right: Box<Expression>,
    },

    Scope {
        statements: Vec<Statement>,
    },

    IfElse {
        consequences: Vec<IfConsequence>,
        else_consequence: Option<ElseConsequence>,
    },

    Function {
        generics: Vec<TypeVarId>,
        parameters: Vec<FunctionParameter>,
        return_type: Type,
        body: Box<Expression>,
    },

    Call {
        function: Box<Expression>,
        arguments: Vec<Expression>,
    },

    Array {
        items: Vec<Expression>,
    },

    HashMap {
        items: Vec<HashMapItem>,
    },

    Index {
        left: Box<Expression>,
        index: Box<Expression>,
    },
}

#[derive(Serialize, Clone, Debug)]
pub struct Program {
    pub statements: Vec<Statement>,
}