mihama 0.0.1

A Modern Functional and Dependent Type Programming Language Base on Rust
Documentation 
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
109
110
111
112
113
114
115
116
117
118
119
120

use crate::checker::object::{TypeObject, PRIMIVE_TYPES};
use crate::evaluator::object::Object;
use crate::parser::ast::Expr;
use std::collections::HashMap;

#[derive(Debug, Clone)]
pub struct Env<'a, T: Clone> {
    pub parent: Option<&'a Env<'a, T>>,
    pub binds: HashMap<String, T>,
}

#[derive(Debug, Clone)]
pub enum EnvError {
    RedefinedBinding(String),
}

impl<T: Clone> PartialEq for Env<'_, T> {
    fn eq(&self, _: &Self) -> bool {
        false
    }
}

impl<'a, T: Clone> Env<'a, T> {
    pub fn new() -> Self {
        Env {
            parent: None,
            binds: HashMap::new(),
        }
    }

    pub fn extend(parent: &'a Env<'a, T>) -> Env<'a, T> {
        Env {
            parent: Some(parent),
            binds: HashMap::new(),
        }
    }

    pub fn insert_bind(&mut self, name: String, value: T) -> Result<(), EnvError> {
        if self.binds.contains_key(&name) {
            Err(EnvError::RedefinedBinding(name))
        } else {
            self.binds.insert(name, value);
            Ok(())
        }
    }

    pub fn get_bind(&self, name: &str) -> Option<T> {
        if let Some(bind) = self.get_own_bind(name) {
            Some(bind)
        } else if let Some(ref parent) = self.parent {
            parent.get_bind(name)
        } else {
            None
        }
    }

    pub fn get_own_bind(&self, name: &str) -> Option<T> {
        if let Some(bind) = self.binds.get(name) {
            Some(bind.clone())
        } else {
            None
        }
    }
}

pub fn new_checker_env<'a>() -> CheckerEnv<'a> {
    let mut env = Env::<'_, TypeObject>::new();
    for t in PRIMIVE_TYPES.iter() {
        env.insert_bind(t.to_string(), t.clone()).unwrap();
    }
    env.insert_bind(
        "print".to_string(),
        TypeObject::Function(
            Box::new(TypeObject::Any.into()),
            Box::new(TypeObject::Unit.into()),
        ),
    )
    .unwrap();
    env.insert_bind(
        "get_timestrap".to_string(),
        TypeObject::Function(
            Box::new(TypeObject::Unit.into()),
            Box::new(TypeObject::Float.into()),
        ),
    )
    .unwrap();
    env
}

pub fn new_evaluator_env<'a>() -> EvaluatorEnv<'a> {
    let mut env = Env::<'_, Object>::new();
    for t in PRIMIVE_TYPES.iter() {
        env.insert_bind(t.to_string(), Object::Type(t.clone()))
            .unwrap();
    }
    env.insert_bind(
        "print".to_string(),
        Object::Function {
            type_params: vec![],
            params: vec![("...args".to_string(), Box::new(TypeObject::Any.into()))],
            body: Box::new(Expr::Ident("print".to_string())),
            return_type: Box::new(TypeObject::Unit.into()),
        },
    )
    .unwrap();
    env.insert_bind(
        "get_timestrap".to_string(),
        Object::Function {
            type_params: vec![],
            params: vec![],
            body: Box::new(Expr::Ident("get_timestrap".to_string())),
            return_type: Box::new(TypeObject::Float.into()),
        },
    )
    .unwrap();
    env
}

pub type CheckerEnv<'a> = Env<'a, TypeObject>;
pub type EvaluatorEnv<'a> = Env<'a, Object>;