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
|
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),
OtherError
}
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()),
}
}
}
|
