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
|
pub mod util;
pub mod display;
pub mod check;
pub mod subst;
pub mod conversion;
use crate::sexp::SExp;
#[derive(Clone,Debug,PartialEq)]
pub enum Type {
Integer,
Boolean,
TypeLit,
QuoteTy, //constructor
Arrow(Box<Type>, Box<Type>),
List(Vec<Type>),
NilType,
VecOf(Box<Type>),
VecType, // constructor
LetType,
/// Type for generics
/// and also error messages
/// with unknown types
VarType(String),
}
#[derive(Debug,PartialEq)]
pub enum TypeError {
UndefinedVariable(String),
UnboundGeneric(String),
InvalidOperator {
operator: SExp,
expected: Type,
found: Type,
},
InvalidArgList {
arglist: SExp,
expected: Type,
found: Type,
},
ArgumentsDontMatchGeneric {
argtype: Type,
generictype: Type,
},
LetAsOperator(SExp),
FunAsAtom,
InvalidFunDef(SExp, FunDefError),
OtherError
}
#[derive(Debug,PartialEq)]
pub enum FunDefError {
NoFunToken,
NoArgumentList,
NoTypeList,
NoReturnType,
NoFunctionBody,
InvalidArgumentList,
InvalidTypeList,
InvalidReturnType,
}
use Type::*;
impl Type {
/// Tests if the type has no variable types.
///
/// **Examples**
/// ```rust
/// use myslip::r#type::{*, Type::*, TypeError::*, util::*};
///
/// assert_eq!(Integer.is_concrete(), Ok(()));
/// assert_eq!(Boolean.is_concrete(), Ok(()));
/// assert_eq!(
/// VarType("a".to_string()).is_concrete(),
/// Err("a".to_string())
/// );
///
/// assert_eq!(arr(Integer, Integer).is_concrete(), Ok(()));
/// assert_eq!(arr(Integer, Boolean).is_concrete(), Ok(()));
/// assert_eq!(
/// arr(VarType("b".to_string()), Integer).is_concrete(),
/// Err("b".to_string())
/// );
///
/// assert_eq!(
/// List(vec![Integer, Boolean, arr(Integer, Integer)]).is_concrete(),
/// Ok(())
/// );
/// assert_eq!(
/// List(vec![Integer, VarType("a".to_string()), Integer])
/// .is_concrete(),
/// Err("a".to_string())
/// );
///
/// assert_eq!(vecof(vt("a")).is_concrete(), Err("a".to_string()));
/// assert_eq!(vecof(Integer).is_concrete(), Ok(()));
/// ```
pub fn is_concrete(&self) -> Result<(), String> {
match self {
Integer => Ok(()),
Boolean => Ok(()),
QuoteTy => Ok(()),
VecType => Ok(()),
LetType => Ok(()),
NilType => Ok(()),
TypeLit => Ok(()),
Arrow(a, b) => b.is_concrete().and_then(|_ok| a.is_concrete()),
List(v) => {
let mut res = Ok(());
for t in v {
res = res.and_then(|_ok| t.is_concrete());
}
res
},
VecOf(ty) => (*ty).is_concrete(),
VarType(s) => Err(s.clone()),
}
}
}
|
