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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use core::fmt;
use std::fmt::{Display, Formatter};

use crate::parser::ast::TypeExpr;

#[derive(Clone, PartialEq, Debug)]
pub enum TypeObject {
    Kind,
    Int,
    Float,
    String,
    Char,
    Bool,
    Unit,
    Unknown,
    Any,
    // Array(Box<TypeObject>),
    Function(Box<TypeObject>, Box<TypeObject>),
    ADT {
        name: String,
        type_params: Vec<String>,
        constructors: Vec<(String, Vec<TypeExpr>)>,
    },
}

pub static PRIMIVE_TYPES: [TypeObject; 9] = [
    TypeObject::Kind,
    TypeObject::Int,
    TypeObject::Float,
    TypeObject::String,
    TypeObject::Char,
    TypeObject::Bool,
    TypeObject::Unit,
    TypeObject::Unknown,
    TypeObject::Any,
];

impl Into<TypeExpr> for TypeObject {
    fn into(self) -> TypeExpr {
        match self {
            TypeObject::Int
            | TypeObject::Float
            | TypeObject::String
            | TypeObject::Char
            | TypeObject::Bool
            | TypeObject::Kind
            | TypeObject::Unit
            | TypeObject::Unknown
            | TypeObject::Any => TypeExpr::Con(self.to_string()),
            // TypeObject::Array(t) => {
            //     TypeExpr::App(Box::new(TypeExpr::Con("Array".to_string())), vec![t.into()])
            // }
            TypeObject::Function(param, ret) => TypeExpr::Arrow(
                Box::new(param.as_ref().clone().into()),
                Box::new(ret.as_ref().clone().into()),
            ),
            TypeObject::ADT {
                name,
                type_params,
                constructors,
            } => {
                let mut args = vec![];
                for (_, ts) in constructors {
                    args.extend(ts.iter().cloned());
                }
                TypeExpr::App(
                    Box::new(TypeExpr::Con(name)),
                    type_params
                        .iter()
                        .map(|s| TypeExpr::Var(s.clone()))
                        .collect(),
                )
            }
        }
    }
}

// impl Into<TypeObject> for TypeExpr {
//     fn into(self) -> TypeObject {
//         match self {
//             TypeExpr::Con(name) => match name.as_str() {
//                 "Int" => TypeObject::Int,
//                 "Float" => TypeObject::Float,
//                 "String" => TypeObject::String,
//                 "Char" => TypeObject::Char,
//                 "Bool" => TypeObject::Bool,
//                 "Kind" => TypeObject::Kind,
//                 "Unit" => TypeObject::Unit,
//                 "Unknown" => TypeObject::Unknown,
//                 "Any" => TypeObject::Any,
//                 _ => TypeObject::ADT {
//                     name,
//                     type_params: vec![],
//                     constructors: vec![],
//                 },
//             },
//             TypeExpr::App(f, args) => {
//                 let f = f.as_ref().clone().into();
//                 let args = args
//                     .iter()
//                     .map(|t| t.clone().into())
//                     .collect::<Vec<TypeObject>>();
//                 match f {
//                     TypeExpr::Con(name) => match name.as_str() {
//                         "Array" => {
//                             // TypeObject::Array(Box::new(args[0].into()))
//                             unimplemented!()
//                         }
//                         _ => TypeObject::ADT {
//                             name,
//                             type_params: vec![],
//                             constructors: vec![],
//                         },
//                     },
//                     TypeExpr::Var(_) => TypeObject::Unknown,
//                     TypeExpr::Arrow(param, ret) => {
//                         TypeObject::Function(Box::new((*param).into()), Box::new((*ret).into()))
//                     }
//                     TypeExpr::App(_, _) => TypeObject::Unknown,
//                     TypeExpr::Literal(_) => TypeObject::Unknown,
//                 }
//             }
//             TypeExpr::Arrow(param, ret) => {
//                 TypeObject::Function(Box::new((*param).into()), Box::new((*ret).into()))
//             }
//             TypeExpr::Var(_) => TypeObject::Unknown,
//             TypeExpr::Literal(_) => TypeObject::Unknown,
//         }
//     }
// }

impl Display for TypeObject {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        match self {
            TypeObject::Kind => write!(f, "Kind"),
            TypeObject::Int => write!(f, "Int"),
            TypeObject::Float => write!(f, "Float"),
            TypeObject::String => write!(f, "String"),
            TypeObject::Char => write!(f, "Char"),
            TypeObject::Bool => write!(f, "Bool"),
            TypeObject::Unit => write!(f, "Unit"),
            TypeObject::Unknown => write!(f, "Unknown"),
            TypeObject::Any => write!(f, "*"),
            // TypeObject::Array(t) => write!(f, "[{}]", t),
            TypeObject::Function(param, ret) => {
                if matches!(**param, TypeObject::Function(_, _)) {
                    write!(f, "({}) -> {}", param, ret)
                } else {
                    write!(f, "{} -> {}", param, ret)
                }
            }
            TypeObject::ADT { name, .. } => write!(f, "{}", name),
        }
    }
}