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
|
use crate::error::{TypeError, TypeMessage};
use crate::semantics::normalize_tyexpr_whnf;
use crate::semantics::{rc, NameEnv, NzEnv, TyEnv, Value};
use crate::syntax::{ExprKind, Span, V};
use crate::Normalized;
use crate::{NormalizedExpr, ToExprOptions};
pub(crate) type Type = Value;
/// Stores an alpha-normalized variable.
#[derive(Debug, Clone, Copy)]
pub struct AlphaVar {
idx: usize,
}
#[derive(Debug, Clone)]
pub(crate) enum TyExprKind {
Var(AlphaVar),
// Forbidden ExprKind variants: Var, Import, Embed
Expr(ExprKind<TyExpr, Normalized>),
}
// An expression with inferred types at every node and resolved variables.
#[derive(Clone)]
pub(crate) struct TyExpr {
kind: Box<TyExprKind>,
ty: Option<Type>,
span: Span,
}
impl AlphaVar {
pub(crate) fn new(idx: usize) -> Self {
AlphaVar { idx }
}
pub(crate) fn idx(&self) -> usize {
self.idx
}
}
impl TyExpr {
pub fn new(kind: TyExprKind, ty: Option<Type>, span: Span) -> Self {
TyExpr {
kind: Box::new(kind),
ty,
span,
}
}
pub fn kind(&self) -> &TyExprKind {
&*self.kind
}
pub fn span(&self) -> &Span {
&self.span
}
pub fn get_type(&self) -> Result<Type, TypeError> {
match &self.ty {
Some(t) => Ok(t.clone()),
None => Err(TypeError::new(TypeMessage::Sort)),
}
}
/// Converts a value back to the corresponding AST expression.
pub fn to_expr(&self, opts: ToExprOptions) -> NormalizedExpr {
tyexpr_to_expr(self, opts, &mut NameEnv::new())
}
pub fn to_expr_tyenv(&self, env: &TyEnv) -> NormalizedExpr {
let opts = ToExprOptions {
normalize: true,
alpha: false,
};
let mut env = env.as_nameenv().clone();
tyexpr_to_expr(self, opts, &mut env)
}
/// Eval the TyExpr. It will actually get evaluated only as needed on demand.
pub fn eval(&self, env: &NzEnv) -> Value {
Value::new_thunk(env, self.clone())
}
/// Eval a closed TyExpr (i.e. without free variables). It will actually get evaluated only as
/// needed on demand.
pub fn eval_closed_expr(&self) -> Value {
self.eval(&NzEnv::new())
}
/// Eval a closed TyExpr fully and recursively;
pub fn rec_eval_closed_expr(&self) -> Value {
normalize_tyexpr_whnf(self, &NzEnv::new())
}
}
fn tyexpr_to_expr<'a>(
tyexpr: &'a TyExpr,
opts: ToExprOptions,
env: &mut NameEnv,
) -> NormalizedExpr {
rc(match tyexpr.kind() {
TyExprKind::Var(v) if opts.alpha => {
ExprKind::Var(V("_".into(), v.idx()))
}
TyExprKind::Var(v) => ExprKind::Var(env.label_var(v)),
TyExprKind::Expr(e) => {
let e = e.map_ref_maybe_binder(|l, tye| {
if let Some(l) = l {
env.insert_mut(l);
}
let e = tyexpr_to_expr(tye, opts, env);
if let Some(_) = l {
env.remove_mut();
}
e
});
match e {
ExprKind::Lam(_, t, e) if opts.alpha => {
ExprKind::Lam("_".into(), t, e)
}
ExprKind::Pi(_, t, e) if opts.alpha => {
ExprKind::Pi("_".into(), t, e)
}
e => e,
}
}
})
}
impl std::fmt::Debug for TyExpr {
fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut x = fmt.debug_struct("TyExpr");
x.field("kind", self.kind());
if let Some(ty) = self.ty.as_ref() {
x.field("type", &ty);
} else {
x.field("type", &None::<()>);
}
x.finish()
}
}
|
