From d035e6ea0783cc270b70238bbbc1387fe511e576 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 27 Dec 2019 15:17:58 +0000
Subject: TypecheckContext doesn't need PartialEq

---
 dhall/src/semantics/core/context.rs | 9 ---------
 1 file changed, 9 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index f755f72..79f2737 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -133,12 +133,3 @@ impl Subst<Value> for TypecheckContext {
         self.subst_shift(var, val)
     }
 }
-
-/// Don't count contexts when comparing stuff.
-/// This is dirty but needed.
-impl PartialEq for TypecheckContext {
-    fn eq(&self, _: &Self) -> bool {
-        true
-    }
-}
-impl Eq for TypecheckContext {}
-- 
cgit v1.2.3


From 89003e1652a41419a1b6dd14f0a8a0769911a7cc Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 27 Dec 2019 15:21:37 +0000
Subject: TypecheckContext doesn't need Rc

It's almost never cloned anymore
---
 dhall/src/semantics/core/context.rs | 32 ++++++++++++++++++--------------
 1 file changed, 18 insertions(+), 14 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index 79f2737..c198e8e 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -1,5 +1,4 @@
 use std::collections::HashMap;
-use std::rc::Rc;
 
 use crate::error::TypeError;
 use crate::semantics::core::value::Value;
@@ -14,21 +13,24 @@ enum CtxItem {
 }
 
 #[derive(Debug, Clone)]
-pub(crate) struct TypecheckContext(Rc<Vec<(Label, CtxItem)>>);
+pub(crate) struct TypecheckContext(Vec<(Label, CtxItem)>);
 
 impl TypecheckContext {
     pub fn new() -> Self {
-        TypecheckContext(Rc::new(Vec::new()))
+        TypecheckContext(Vec::new())
+    }
+    fn with_vec(&self, vec: Vec<(Label, CtxItem)>) -> Self {
+        TypecheckContext(vec)
     }
     pub fn insert_type(&self, x: &Label, t: Value) -> Self {
-        let mut vec = self.0.as_ref().clone();
+        let mut vec = self.0.clone();
         vec.push((x.clone(), CtxItem::Kept(x.into(), t.under_binder(x))));
-        TypecheckContext(Rc::new(vec))
+        self.with_vec(vec)
     }
     pub fn insert_value(&self, x: &Label, e: Value) -> Result<Self, TypeError> {
-        let mut vec = self.0.as_ref().clone();
+        let mut vec = self.0.clone();
         vec.push((x.clone(), CtxItem::Replaced(e)));
-        Ok(TypecheckContext(Rc::new(vec)))
+        Ok(self.with_vec(vec))
     }
     pub fn lookup(&self, var: &V<Label>) -> Option<Value> {
         let mut var = var.clone();
@@ -79,18 +81,20 @@ impl TypecheckContext {
             vec.push((l.clone(), (*i).clone()));
         }
         vec.reverse();
-        Ok(TypecheckContext(Rc::new(vec)))
+        Ok(self.with_vec(vec))
     }
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
         if delta < 0 {
             Some(self.do_with_var(var, |var, i| Ok(i.shift(delta, &var)?))?)
         } else {
-            Some(TypecheckContext(Rc::new(
-                self.0
-                    .iter()
-                    .map(|(l, i)| Ok((l.clone(), i.shift(delta, &var)?)))
-                    .collect::<Result<_, _>>()?,
-            )))
+            Some(
+                self.with_vec(
+                    self.0
+                        .iter()
+                        .map(|(l, i)| Ok((l.clone(), i.shift(delta, &var)?)))
+                        .collect::<Result<_, _>>()?,
+                ),
+            )
         }
     }
     fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
-- 
cgit v1.2.3


From e97e0c8e9905582aef826504b59a1844c8f67613 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 27 Dec 2019 15:29:59 +0000
Subject: Make TypecheckContext a named struct

---
 dhall/src/semantics/core/context.rs | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index c198e8e..5a0c320 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -13,29 +13,31 @@ enum CtxItem {
 }
 
 #[derive(Debug, Clone)]
-pub(crate) struct TypecheckContext(Vec<(Label, CtxItem)>);
+pub(crate) struct TypecheckContext {
+    ctx: Vec<(Label, CtxItem)>,
+}
 
 impl TypecheckContext {
     pub fn new() -> Self {
-        TypecheckContext(Vec::new())
+        TypecheckContext { ctx: Vec::new() }
     }
     fn with_vec(&self, vec: Vec<(Label, CtxItem)>) -> Self {
-        TypecheckContext(vec)
+        TypecheckContext { ctx: vec }
     }
     pub fn insert_type(&self, x: &Label, t: Value) -> Self {
-        let mut vec = self.0.clone();
+        let mut vec = self.ctx.clone();
         vec.push((x.clone(), CtxItem::Kept(x.into(), t.under_binder(x))));
         self.with_vec(vec)
     }
     pub fn insert_value(&self, x: &Label, e: Value) -> Result<Self, TypeError> {
-        let mut vec = self.0.clone();
+        let mut vec = self.ctx.clone();
         vec.push((x.clone(), CtxItem::Replaced(e)));
         Ok(self.with_vec(vec))
     }
     pub fn lookup(&self, var: &V<Label>) -> Option<Value> {
         let mut var = var.clone();
         let mut shift_map: HashMap<Label, _> = HashMap::new();
-        for (l, i) in self.0.iter().rev() {
+        for (l, i) in self.ctx.iter().rev() {
             match var.over_binder(l) {
                 None => {
                     let i = i.under_multiple_binders(&shift_map);
@@ -65,9 +67,9 @@ impl TypecheckContext {
         mut f: impl FnMut(&AlphaVar, &CtxItem) -> Result<CtxItem, E>,
     ) -> Result<Self, E> {
         let mut vec = Vec::new();
-        vec.reserve(self.0.len());
+        vec.reserve(self.ctx.len());
         let mut var = var.clone();
-        let mut iter = self.0.iter().rev();
+        let mut iter = self.ctx.iter().rev();
         for (l, i) in iter.by_ref() {
             vec.push((l.clone(), f(&var, i)?));
             if let CtxItem::Kept(_, _) = i {
@@ -89,7 +91,7 @@ impl TypecheckContext {
         } else {
             Some(
                 self.with_vec(
-                    self.0
+                    self.ctx
                         .iter()
                         .map(|(l, i)| Ok((l.clone(), i.shift(delta, &var)?)))
                         .collect::<Result<_, _>>()?,
-- 
cgit v1.2.3


From 5542797c77a9dfcdffec539f1a82341a450291a2 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 27 Dec 2019 15:31:06 +0000
Subject: s/TypecheckContext/TyCtx/

---
 dhall/src/error/mod.rs                 |  9 +++------
 dhall/src/semantics/core/context.rs    | 12 ++++++------
 dhall/src/semantics/core/value.rs      |  6 ++----
 dhall/src/semantics/phase/typecheck.rs | 22 ++++++++--------------
 4 files changed, 19 insertions(+), 30 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index 6e7be64..56bc8ab 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -1,6 +1,6 @@
 use std::io::Error as IOError;
 
-use crate::semantics::core::context::TypecheckContext;
+use crate::semantics::core::context::TyCtx;
 use crate::semantics::core::value::Value;
 use crate::semantics::phase::resolve::ImportStack;
 use crate::semantics::phase::NormalizedExpr;
@@ -41,7 +41,7 @@ pub enum EncodeError {
 #[derive(Debug)]
 pub struct TypeError {
     message: TypeMessage,
-    context: TypecheckContext,
+    context: TyCtx,
 }
 
 /// The specific type error
@@ -88,10 +88,7 @@ pub(crate) enum TypeMessage {
 }
 
 impl TypeError {
-    pub(crate) fn new(
-        context: &TypecheckContext,
-        message: TypeMessage,
-    ) -> Self {
+    pub(crate) fn new(context: &TyCtx, message: TypeMessage) -> Self {
         TypeError {
             context: context.clone(),
             message,
diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index 5a0c320..ed63b63 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -13,16 +13,16 @@ enum CtxItem {
 }
 
 #[derive(Debug, Clone)]
-pub(crate) struct TypecheckContext {
+pub(crate) struct TyCtx {
     ctx: Vec<(Label, CtxItem)>,
 }
 
-impl TypecheckContext {
+impl TyCtx {
     pub fn new() -> Self {
-        TypecheckContext { ctx: Vec::new() }
+        TyCtx { ctx: Vec::new() }
     }
     fn with_vec(&self, vec: Vec<(Label, CtxItem)>) -> Self {
-        TypecheckContext { ctx: vec }
+        TyCtx { ctx: vec }
     }
     pub fn insert_type(&self, x: &Label, t: Value) -> Self {
         let mut vec = self.ctx.clone();
@@ -116,7 +116,7 @@ impl Shift for CtxItem {
     }
 }
 
-impl Shift for TypecheckContext {
+impl Shift for TyCtx {
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
         self.shift(delta, var)
     }
@@ -134,7 +134,7 @@ impl Subst<Value> for CtxItem {
     }
 }
 
-impl Subst<Value> for TypecheckContext {
+impl Subst<Value> for TyCtx {
     fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
         self.subst_shift(var, val)
     }
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 6fa00ac..f06c614 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
-use crate::semantics::core::context::TypecheckContext;
+use crate::semantics::core::context::TyCtx;
 use crate::semantics::core::var::{AlphaLabel, AlphaVar, Shift, Subst};
 use crate::semantics::phase::normalize::{apply_any, normalize_whnf};
 use crate::semantics::phase::typecheck::{builtin_to_value, const_to_value};
@@ -292,9 +292,7 @@ impl ValueInternal {
     fn get_type(&self) -> Result<&Value, TypeError> {
         match &self.ty {
             Some(t) => Ok(t),
-            None => {
-                Err(TypeError::new(&TypecheckContext::new(), TypeMessage::Sort))
-            }
+            None => Err(TypeError::new(&TyCtx::new(), TypeMessage::Sort)),
         }
     }
 }
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index 3960146..16eabea 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -3,7 +3,7 @@ use std::cmp::max;
 use std::collections::HashMap;
 
 use crate::error::{TypeError, TypeMessage};
-use crate::semantics::core::context::TypecheckContext;
+use crate::semantics::core::context::TyCtx;
 use crate::semantics::core::value::Value;
 use crate::semantics::core::value::ValueKind;
 use crate::semantics::core::var::{Shift, Subst};
@@ -16,7 +16,7 @@ use crate::syntax::{
 };
 
 fn tck_pi_type(
-    ctx: &TypecheckContext,
+    ctx: &TyCtx,
     x: Label,
     tx: Value,
     te: Value,
@@ -48,7 +48,7 @@ fn tck_pi_type(
 }
 
 fn tck_record_type(
-    ctx: &TypecheckContext,
+    ctx: &TyCtx,
     kts: impl IntoIterator<Item = Result<(Label, Value), TypeError>>,
 ) -> Result<Value, TypeError> {
     use std::collections::hash_map::Entry;
@@ -79,10 +79,7 @@ fn tck_record_type(
     ))
 }
 
-fn tck_union_type<Iter>(
-    ctx: &TypecheckContext,
-    kts: Iter,
-) -> Result<Value, TypeError>
+fn tck_union_type<Iter>(ctx: &TyCtx, kts: Iter) -> Result<Value, TypeError>
 where
     Iter: IntoIterator<Item = Result<(Label, Option<Value>), TypeError>>,
 {
@@ -294,7 +291,7 @@ fn type_of_builtin<E>(b: Builtin) -> Expr<E> {
 }
 
 pub(crate) fn builtin_to_value(b: Builtin) -> Value {
-    let ctx = TypecheckContext::new();
+    let ctx = TyCtx::new();
     Value::from_kind_and_type(
         ValueKind::from_builtin(b),
         type_with(&ctx, type_of_builtin(b)).unwrap(),
@@ -305,10 +302,7 @@ pub(crate) fn builtin_to_value(b: Builtin) -> Value {
 /// succeeded, or an error if type-checking failed.
 /// Some normalization is done while typechecking, so the returned expression might be partially
 /// normalized as well.
-fn type_with(
-    ctx: &TypecheckContext,
-    e: Expr<Normalized>,
-) -> Result<Value, TypeError> {
+fn type_with(ctx: &TyCtx, e: Expr<Normalized>) -> Result<Value, TypeError> {
     use syntax::ExprKind::{Annot, Embed, Lam, Let, Pi, Var};
     let span = e.span();
 
@@ -364,7 +358,7 @@ fn type_with(
 /// When all sub-expressions have been typed, check the remaining toplevel
 /// layer.
 fn type_last_layer(
-    ctx: &TypecheckContext,
+    ctx: &TyCtx,
     e: ExprKind<Value, Normalized>,
     span: Span,
 ) -> Result<Value, TypeError> {
@@ -827,7 +821,7 @@ fn type_last_layer(
 /// expression must be closed (i.e. no free variables), otherwise type-checking
 /// will fail.
 pub(crate) fn typecheck(e: Expr<Normalized>) -> Result<Value, TypeError> {
-    type_with(&TypecheckContext::new(), e)
+    type_with(&TyCtx::new(), e)
 }
 
 pub(crate) fn typecheck_with(
-- 
cgit v1.2.3


From ce706817dcb5cb951c566410de92a4f85aae5361 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 27 Dec 2019 15:36:10 +0000
Subject: Tiny clarification

---
 dhall/src/semantics/phase/typecheck.rs | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index 16eabea..c8d934d 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -306,23 +306,23 @@ fn type_with(ctx: &TyCtx, e: Expr<Normalized>) -> Result<Value, TypeError> {
     use syntax::ExprKind::{Annot, Embed, Lam, Let, Pi, Var};
     let span = e.span();
 
-    Ok(match e.as_ref() {
+    match e.as_ref() {
         Lam(var, annot, body) => {
             let annot = type_with(ctx, annot.clone())?;
             annot.normalize_nf();
             let ctx2 = ctx.insert_type(var, annot.clone());
             let body = type_with(&ctx2, body.clone())?;
             let body_type = body.get_type()?;
-            Value::from_kind_and_type(
+            Ok(Value::from_kind_and_type(
                 ValueKind::Lam(var.clone().into(), annot.clone(), body),
                 tck_pi_type(ctx, var.clone(), annot, body_type)?,
-            )
+            ))
         }
         Pi(x, ta, tb) => {
             let ta = type_with(ctx, ta.clone())?;
             let ctx2 = ctx.insert_type(x, ta.clone());
             let tb = type_with(&ctx2, tb.clone())?;
-            return tck_pi_type(ctx, x.clone(), ta, tb);
+            tck_pi_type(ctx, x.clone(), ta, tb)
         }
         Let(x, t, v, e) => {
             let v = if let Some(t) = t {
@@ -332,16 +332,13 @@ fn type_with(ctx: &TyCtx, e: Expr<Normalized>) -> Result<Value, TypeError> {
             };
 
             let v = type_with(ctx, v)?;
-            return type_with(&ctx.insert_value(x, v.clone())?, e.clone());
+            type_with(&ctx.insert_value(x, v.clone())?, e.clone())
         }
-        Embed(p) => p.clone().into_typed().into_value(),
+        Embed(p) => Ok(p.clone().into_typed().into_value()),
         Var(var) => match ctx.lookup(&var) {
-            Some(typed) => typed.clone(),
+            Some(typed) => Ok(typed.clone()),
             None => {
-                return Err(TypeError::new(
-                    ctx,
-                    TypeMessage::UnboundVariable(span),
-                ))
+                Err(TypeError::new(ctx, TypeMessage::UnboundVariable(span)))
             }
         },
         e => {
@@ -350,9 +347,9 @@ fn type_with(ctx: &TyCtx, e: Expr<Normalized>) -> Result<Value, TypeError> {
                 |e| type_with(ctx, e.clone()),
                 |_, _| unreachable!(),
             )?;
-            type_last_layer(ctx, expr, span)?
+            type_last_layer(ctx, expr, span)
         }
-    })
+    }
 }
 
 /// When all sub-expressions have been typed, check the remaining toplevel
-- 
cgit v1.2.3


From 015b76ce47af5b1b31661a934aee13843215c6b0 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 27 Dec 2019 16:48:33 +0000
Subject: Construct T/Build closures in Expr space

---
 dhall/src/semantics/core/var.rs        |   6 --
 dhall/src/semantics/phase/normalize.rs | 113 +++++++++++++++++----------------
 dhall/src/semantics/phase/typecheck.rs |   3 +-
 3 files changed, 58 insertions(+), 64 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index 1548713..017a689 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -62,12 +62,6 @@ impl AlphaVar {
             self.normal.clone()
         }
     }
-    pub(crate) fn from_var_and_alpha(normal: V<Label>, alpha: usize) -> Self {
-        AlphaVar {
-            normal,
-            alpha: V((), alpha),
-        }
-    }
 }
 
 impl AlphaLabel {
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index bf0c626..0c581fe 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -3,7 +3,8 @@ use std::convert::TryInto;
 
 use crate::semantics::core::value::Value;
 use crate::semantics::core::value::ValueKind;
-use crate::semantics::core::var::{AlphaLabel, AlphaVar, Shift, Subst};
+use crate::semantics::core::var::Subst;
+use crate::semantics::phase::typecheck::{rc, typecheck};
 use crate::semantics::phase::Normalized;
 use crate::syntax;
 use crate::syntax::Const::Type;
@@ -14,60 +15,51 @@ use crate::syntax::{
 
 // Ad-hoc macro to help construct closures
 macro_rules! make_closure {
-    (#$var:ident) => { $var.clone() };
-    (var($var:ident, $n:expr, $($ty:tt)*)) => {{
-        let var = AlphaVar::from_var_and_alpha(
+    (var($var:ident)) => {{
+        rc(ExprKind::Var(syntax::V(
             Label::from(stringify!($var)).into(),
-            $n
-        );
-        ValueKind::Var(var)
-            .into_value_with_type(make_closure!($($ty)*))
+            0
+        )))
     }};
-    // Warning: assumes that $ty, as a dhall value, has type `Type`
     (λ($var:tt : $($ty:tt)*) -> $($body:tt)*) => {{
-        let var: AlphaLabel = Label::from(stringify!($var)).into();
+        let var = Label::from(stringify!($var));
         let ty = make_closure!($($ty)*);
         let body = make_closure!($($body)*);
-        let body_ty = body.get_type_not_sort();
-        let lam_ty = ValueKind::Pi(var.clone(), ty.clone(), body_ty)
-            .into_value_with_type(Value::from_const(Type));
-        ValueKind::Lam(var, ty, body).into_value_with_type(lam_ty)
+        rc(ExprKind::Lam(var, ty, body))
     }};
-    (Natural) => {
-        Value::from_builtin(Builtin::Natural)
+    (Type) => {
+        rc(ExprKind::Const(Type))
     };
-    (List $($rest:tt)*) => {
-        Value::from_builtin(Builtin::List)
-            .app(make_closure!($($rest)*))
+    (Natural) => {
+        rc(ExprKind::Builtin(Builtin::Natural))
     };
-    (Some($($rest:tt)*)) => {{
-        let v = make_closure!($($rest)*);
-        let v_type = v.get_type_not_sort();
-        let opt_v_type = Value::from_builtin(Builtin::Optional).app(v_type);
-        ValueKind::NEOptionalLit(v).into_value_with_type(opt_v_type)
+    (List $($ty:tt)*) => {{
+        let ty = make_closure!($($ty)*);
+        rc(ExprKind::App(
+            rc(ExprKind::Builtin(Builtin::List)),
+            ty
+        ))
     }};
-    (1 + $($rest:tt)*) => {
-        ValueKind::PartialExpr(ExprKind::BinOp(
+    (Some($($v:tt)*)) => {
+        rc(ExprKind::SomeLit(
+            make_closure!($($v)*)
+        ))
+    };
+    (1 + $($v:tt)*) => {
+        rc(ExprKind::BinOp(
             syntax::BinOp::NaturalPlus,
-            make_closure!($($rest)*),
-            Value::from_kind_and_type(
-                ValueKind::NaturalLit(1),
-                make_closure!(Natural)
-            ),
-        )).into_value_with_type(
-            make_closure!(Natural)
-        )
+            make_closure!($($v)*),
+            rc(ExprKind::NaturalLit(1))
+        ))
     };
     ([ $($head:tt)* ] # $($tail:tt)*) => {{
         let head = make_closure!($($head)*);
         let tail = make_closure!($($tail)*);
-        let list_type = tail.get_type_not_sort();
-        ValueKind::PartialExpr(ExprKind::BinOp(
+        rc(ExprKind::BinOp(
             syntax::BinOp::ListAppend,
-            ValueKind::NEListLit(vec![head])
-                .into_value_with_type(list_type.clone()),
+            rc(ExprKind::NEListLit(vec![head])),
             tail,
-        )).into_value_with_type(list_type)
+        ))
     }};
 }
 
@@ -274,16 +266,16 @@ pub(crate) fn apply_builtin(
             let list_t = Value::from_builtin(List).app(t.clone());
             Ret::Value(
                 f.app(list_t.clone())
-                    .app({
-                        // Move `t` under new variables
-                        let t1 = t.under_binder(Label::from("a"));
-                        let t2 = t1.under_binder(Label::from("as"));
-                        make_closure!(
-                            λ(a : #t) ->
-                            λ(as : List #t1) ->
-                            [ var(a, 1, #t2) ] # var(as, 0, List #t2)
-                        )
-                    })
+                    .app(
+                        typecheck(make_closure!(
+                            λ(T : Type) ->
+                            λ(a : var(T)) ->
+                            λ(as : List var(T)) ->
+                            [ var(a) ] # var(as)
+                        ))
+                        .unwrap()
+                        .app(t.clone()),
+                    )
                     .app(EmptyListLit(t.clone()).into_value_with_type(list_t)),
             )
         }
@@ -302,10 +294,15 @@ pub(crate) fn apply_builtin(
             let optional_t = Value::from_builtin(Optional).app(t.clone());
             Ret::Value(
                 f.app(optional_t.clone())
-                    .app({
-                        let t1 = t.under_binder(Label::from("a"));
-                        make_closure!(λ(a: #t) -> Some(var(a, 0, #t1)))
-                    })
+                    .app(
+                        typecheck(make_closure!(
+                            λ(T : Type) ->
+                            λ(a : var(T)) ->
+                            Some(var(a))
+                        ))
+                        .unwrap()
+                        .app(t.clone()),
+                    )
                     .app(
                         EmptyOptionalLit(t.clone())
                             .into_value_with_type(optional_t),
@@ -324,9 +321,13 @@ pub(crate) fn apply_builtin(
         },
         (NaturalBuild, [f]) => Ret::Value(
             f.app(Value::from_builtin(Natural))
-                .app(make_closure!(
-                    λ(x : Natural) -> 1 + var(x, 0, Natural)
-                ))
+                .app(
+                    typecheck(make_closure!(
+                        λ(x : Natural) ->
+                        1 + var(x)
+                    ))
+                    .unwrap(),
+                )
                 .app(
                     NaturalLit(0)
                         .into_value_with_type(Value::from_builtin(Natural)),
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index c8d934d..2e1cc02 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -291,10 +291,9 @@ fn type_of_builtin<E>(b: Builtin) -> Expr<E> {
 }
 
 pub(crate) fn builtin_to_value(b: Builtin) -> Value {
-    let ctx = TyCtx::new();
     Value::from_kind_and_type(
         ValueKind::from_builtin(b),
-        type_with(&ctx, type_of_builtin(b)).unwrap(),
+        typecheck(type_of_builtin(b)).unwrap(),
     )
 }
 
-- 
cgit v1.2.3


From c85d8d011445a619aca60c1e4fc2b2657ca9d646 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 27 Dec 2019 14:05:03 +0000
Subject: Implement PartialEq manually for ValueKind

---
 dhall/src/semantics/core/value.rs | 65 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 64 insertions(+), 1 deletion(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index f06c614..37f95ca 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -51,7 +51,7 @@ pub(crate) enum Form {
     NF,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone)]
 pub(crate) enum ValueKind {
     /// Closures
     Lam(AlphaLabel, Value, Value),
@@ -570,6 +570,69 @@ impl std::cmp::PartialEq for Value {
 }
 impl std::cmp::Eq for Value {}
 
+impl std::cmp::PartialEq for ValueKind {
+    fn eq(&self, other: &Self) -> bool {
+        use ValueKind::*;
+        match (self, other) {
+            (Lam(x0, x1, x2), Lam(y0, y1, y2)) => {
+                x0 == y0 && x1 == y1 && x2 == y2
+            }
+            (Pi(x0, x1, x2), Pi(y0, y1, y2)) => {
+                x0 == y0 && x1 == y1 && x2 == y2
+            }
+            (AppliedBuiltin(x0, x1), AppliedBuiltin(y0, y1)) => {
+                x0 == y0 && x1 == y1
+            }
+            (Var(x0), Var(y0)) => x0 == y0,
+            (Const(x0), Const(y0)) => x0 == y0,
+            (BoolLit(x0), BoolLit(y0)) => x0 == y0,
+            (NaturalLit(x0), NaturalLit(y0)) => x0 == y0,
+            (IntegerLit(x0), IntegerLit(y0)) => x0 == y0,
+            (DoubleLit(x0), DoubleLit(y0)) => x0 == y0,
+            (EmptyOptionalLit(x0), EmptyOptionalLit(y0)) => x0 == y0,
+            (NEOptionalLit(x0), NEOptionalLit(y0)) => x0 == y0,
+            (EmptyListLit(x0), EmptyListLit(y0)) => x0 == y0,
+            (NEListLit(x0), NEListLit(y0)) => x0 == y0,
+            (RecordType(x0), RecordType(y0)) => x0 == y0,
+            (RecordLit(x0), RecordLit(y0)) => x0 == y0,
+            (UnionType(x0), UnionType(y0)) => x0 == y0,
+            (UnionConstructor(x0, x1), UnionConstructor(y0, y1)) => {
+                x0 == y0 && x1 == y1
+            }
+            (UnionLit(x0, x1, x2), UnionLit(y0, y1, y2)) => {
+                x0 == y0 && x1 == y1 && x2 == y2
+            }
+            (TextLit(x0), TextLit(y0)) => x0 == y0,
+            (Equivalence(x0, x1), Equivalence(y0, y1)) => x0 == y0 && x1 == y1,
+            (PartialExpr(x0), PartialExpr(y0)) => x0 == y0,
+
+            // Explicitely list all constructors to ensure we don't forget to update this function.
+            (Lam(..), _)
+            | (Pi(..), _)
+            | (AppliedBuiltin(..), _)
+            | (Var(..), _)
+            | (Const(..), _)
+            | (BoolLit(..), _)
+            | (NaturalLit(..), _)
+            | (IntegerLit(..), _)
+            | (DoubleLit(..), _)
+            | (EmptyOptionalLit(..), _)
+            | (NEOptionalLit(..), _)
+            | (EmptyListLit(..), _)
+            | (NEListLit(..), _)
+            | (RecordType(..), _)
+            | (RecordLit(..), _)
+            | (UnionType(..), _)
+            | (UnionConstructor(..), _)
+            | (UnionLit(..), _)
+            | (TextLit(..), _)
+            | (Equivalence(..), _)
+            | (PartialExpr(..), _) => false,
+        }
+    }
+}
+impl std::cmp::Eq for ValueKind {}
+
 impl std::fmt::Debug for Value {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let vint: &ValueInternal = &self.as_internal();
-- 
cgit v1.2.3


From 3603fbf9d321602a2df51e7b3f7a69425bd4d304 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 27 Dec 2019 15:12:26 +0000
Subject: Revert "Implement PartialEq manually for ValueKind"

This reverts commit 88c31554561bd7a600560af0e6bc97c48649f43f.
---
 dhall/src/semantics/core/value.rs | 65 +--------------------------------------
 1 file changed, 1 insertion(+), 64 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 37f95ca..f06c614 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -51,7 +51,7 @@ pub(crate) enum Form {
     NF,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum ValueKind {
     /// Closures
     Lam(AlphaLabel, Value, Value),
@@ -570,69 +570,6 @@ impl std::cmp::PartialEq for Value {
 }
 impl std::cmp::Eq for Value {}
 
-impl std::cmp::PartialEq for ValueKind {
-    fn eq(&self, other: &Self) -> bool {
-        use ValueKind::*;
-        match (self, other) {
-            (Lam(x0, x1, x2), Lam(y0, y1, y2)) => {
-                x0 == y0 && x1 == y1 && x2 == y2
-            }
-            (Pi(x0, x1, x2), Pi(y0, y1, y2)) => {
-                x0 == y0 && x1 == y1 && x2 == y2
-            }
-            (AppliedBuiltin(x0, x1), AppliedBuiltin(y0, y1)) => {
-                x0 == y0 && x1 == y1
-            }
-            (Var(x0), Var(y0)) => x0 == y0,
-            (Const(x0), Const(y0)) => x0 == y0,
-            (BoolLit(x0), BoolLit(y0)) => x0 == y0,
-            (NaturalLit(x0), NaturalLit(y0)) => x0 == y0,
-            (IntegerLit(x0), IntegerLit(y0)) => x0 == y0,
-            (DoubleLit(x0), DoubleLit(y0)) => x0 == y0,
-            (EmptyOptionalLit(x0), EmptyOptionalLit(y0)) => x0 == y0,
-            (NEOptionalLit(x0), NEOptionalLit(y0)) => x0 == y0,
-            (EmptyListLit(x0), EmptyListLit(y0)) => x0 == y0,
-            (NEListLit(x0), NEListLit(y0)) => x0 == y0,
-            (RecordType(x0), RecordType(y0)) => x0 == y0,
-            (RecordLit(x0), RecordLit(y0)) => x0 == y0,
-            (UnionType(x0), UnionType(y0)) => x0 == y0,
-            (UnionConstructor(x0, x1), UnionConstructor(y0, y1)) => {
-                x0 == y0 && x1 == y1
-            }
-            (UnionLit(x0, x1, x2), UnionLit(y0, y1, y2)) => {
-                x0 == y0 && x1 == y1 && x2 == y2
-            }
-            (TextLit(x0), TextLit(y0)) => x0 == y0,
-            (Equivalence(x0, x1), Equivalence(y0, y1)) => x0 == y0 && x1 == y1,
-            (PartialExpr(x0), PartialExpr(y0)) => x0 == y0,
-
-            // Explicitely list all constructors to ensure we don't forget to update this function.
-            (Lam(..), _)
-            | (Pi(..), _)
-            | (AppliedBuiltin(..), _)
-            | (Var(..), _)
-            | (Const(..), _)
-            | (BoolLit(..), _)
-            | (NaturalLit(..), _)
-            | (IntegerLit(..), _)
-            | (DoubleLit(..), _)
-            | (EmptyOptionalLit(..), _)
-            | (NEOptionalLit(..), _)
-            | (EmptyListLit(..), _)
-            | (NEListLit(..), _)
-            | (RecordType(..), _)
-            | (RecordLit(..), _)
-            | (UnionType(..), _)
-            | (UnionConstructor(..), _)
-            | (UnionLit(..), _)
-            | (TextLit(..), _)
-            | (Equivalence(..), _)
-            | (PartialExpr(..), _) => false,
-        }
-    }
-}
-impl std::cmp::Eq for ValueKind {}
-
 impl std::fmt::Debug for Value {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let vint: &ValueInternal = &self.as_internal();
-- 
cgit v1.2.3


From 8edbeadbd0dc06a75ffb8bf3b0a54a62e3acc5fc Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 27 Dec 2019 14:26:40 +0000
Subject: Parameterize ValueKind by its subnodes

---
 dhall/src/semantics/core/value.rs      | 33 ++++++++++++++++++---------------
 dhall/src/semantics/phase/mod.rs       |  2 +-
 dhall/src/semantics/phase/normalize.rs | 15 +++++++++------
 dhall/src/semantics/to_expr.rs         |  2 +-
 4 files changed, 29 insertions(+), 23 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index f06c614..5f244b7 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -30,7 +30,7 @@ pub(crate) struct Value(Rc<RefCell<ValueInternal>>);
 #[derive(Debug)]
 struct ValueInternal {
     form: Form,
-    kind: ValueKind,
+    kind: ValueKind<Value>,
     /// This is None if and only if `value` is `Sort` (which doesn't have a type)
     ty: Option<Value>,
     span: Span,
@@ -52,7 +52,7 @@ pub(crate) enum Form {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) enum ValueKind {
+pub(crate) enum ValueKind<Value> {
     /// Closures
     Lam(AlphaLabel, Value, Value),
     Pi(AlphaLabel, Value, Value),
@@ -84,7 +84,7 @@ pub(crate) enum ValueKind {
 }
 
 impl Value {
-    fn new(kind: ValueKind, form: Form, ty: Value, span: Span) -> Value {
+    fn new(kind: ValueKind<Value>, form: Form, ty: Value, span: Span) -> Value {
         ValueInternal {
             form,
             kind,
@@ -102,17 +102,20 @@ impl Value {
         }
         .into_value()
     }
-    pub(crate) fn from_kind_and_type(v: ValueKind, t: Value) -> Value {
+    pub(crate) fn from_kind_and_type(v: ValueKind<Value>, t: Value) -> Value {
         Value::new(v, Unevaled, t, Span::Artificial)
     }
     pub(crate) fn from_kind_and_type_and_span(
-        v: ValueKind,
+        v: ValueKind<Value>,
         t: Value,
         span: Span,
     ) -> Value {
         Value::new(v, Unevaled, t, span)
     }
-    pub(crate) fn from_kind_and_type_whnf(v: ValueKind, t: Value) -> Value {
+    pub(crate) fn from_kind_and_type_whnf(
+        v: ValueKind<Value>,
+        t: Value,
+    ) -> Value {
         Value::new(v, WHNF, t, Span::Artificial)
     }
     pub(crate) fn from_const(c: Const) -> Self {
@@ -144,13 +147,13 @@ impl Value {
     }
     /// WARNING: The returned ValueKind may be entirely unnormalized, in particular it may just be an
     /// unevaled PartialExpr. You probably want to use `as_whnf`.
-    pub(crate) fn as_kind(&self) -> Ref<ValueKind> {
+    pub(crate) fn as_kind(&self) -> Ref<ValueKind<Value>> {
         Ref::map(self.as_internal(), ValueInternal::as_kind)
     }
     /// This is what you want if you want to pattern-match on the value.
     /// WARNING: drop this ref before normalizing the same value or you will run into BorrowMut
     /// panics.
-    pub(crate) fn as_whnf(&self) -> Ref<ValueKind> {
+    pub(crate) fn as_whnf(&self) -> Ref<ValueKind<Value>> {
         self.normalize_whnf();
         self.as_kind()
     }
@@ -162,11 +165,11 @@ impl Value {
     ) -> NormalizedExpr {
         to_expr::value_to_expr(self, opts)
     }
-    pub(crate) fn to_whnf_ignore_type(&self) -> ValueKind {
+    pub(crate) fn to_whnf_ignore_type(&self) -> ValueKind<Value> {
         self.as_whnf().clone()
     }
     /// Before discarding type information, check that it matches the expected return type.
-    pub(crate) fn to_whnf_check_type(&self, ty: &Value) -> ValueKind {
+    pub(crate) fn to_whnf_check_type(&self, ty: &Value) -> ValueKind<Value> {
         self.check_type(ty);
         self.to_whnf_ignore_type()
     }
@@ -241,7 +244,7 @@ impl ValueInternal {
     fn into_value(self) -> Value {
         Value(Rc::new(RefCell::new(self)))
     }
-    fn as_kind(&self) -> &ValueKind {
+    fn as_kind(&self) -> &ValueKind<Value> {
         &self.kind
     }
 
@@ -297,7 +300,7 @@ impl ValueInternal {
     }
 }
 
-impl ValueKind {
+impl ValueKind<Value> {
     pub(crate) fn into_value_with_type(self, t: Value) -> Value {
         Value::from_kind_and_type(self, t)
     }
@@ -380,7 +383,7 @@ impl ValueKind {
         }
     }
 
-    pub(crate) fn from_builtin(b: Builtin) -> ValueKind {
+    pub(crate) fn from_builtin(b: Builtin) -> ValueKind<Value> {
         ValueKind::AppliedBuiltin(b, vec![])
     }
 }
@@ -402,7 +405,7 @@ impl Shift for ValueInternal {
     }
 }
 
-impl Shift for ValueKind {
+impl Shift for ValueKind<Value> {
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
         Some(match self {
             ValueKind::Lam(x, t, e) => ValueKind::Lam(
@@ -495,7 +498,7 @@ impl Subst<Value> for ValueInternal {
     }
 }
 
-impl Subst<Value> for ValueKind {
+impl Subst<Value> for ValueKind<Value> {
     fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
         match self {
             ValueKind::AppliedBuiltin(b, args) => {
diff --git a/dhall/src/semantics/phase/mod.rs b/dhall/src/semantics/phase/mod.rs
index 5332eb3..104a1ba 100644
--- a/dhall/src/semantics/phase/mod.rs
+++ b/dhall/src/semantics/phase/mod.rs
@@ -94,7 +94,7 @@ impl Typed {
     pub(crate) fn from_const(c: Const) -> Self {
         Typed(Value::from_const(c))
     }
-    pub(crate) fn from_kind_and_type(v: ValueKind, t: Typed) -> Self {
+    pub(crate) fn from_kind_and_type(v: ValueKind<Value>, t: Typed) -> Self {
         Typed(Value::from_kind_and_type(v, t.into_value()))
     }
     pub(crate) fn from_value(th: Value) -> Self {
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index 0c581fe..7b4b37f 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -68,13 +68,13 @@ pub(crate) fn apply_builtin(
     b: Builtin,
     args: Vec<Value>,
     ty: &Value,
-) -> ValueKind {
+) -> ValueKind<Value> {
     use syntax::Builtin::*;
     use ValueKind::*;
 
     // Small helper enum
     enum Ret<'a> {
-        ValueKind(ValueKind),
+        ValueKind(ValueKind<Value>),
         Value(Value),
         // For applications that can return a function, it's important to keep the remaining
         // arguments to apply them to the resulting function.
@@ -365,7 +365,7 @@ pub(crate) fn apply_builtin(
     }
 }
 
-pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind {
+pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
     let f_borrow = f.as_whnf();
     match &*f_borrow {
         ValueKind::Lam(x, _, e) => {
@@ -456,7 +456,7 @@ where
 
 // Small helper enum to avoid repetition
 enum Ret<'a> {
-    ValueKind(ValueKind),
+    ValueKind(ValueKind<Value>),
     Value(Value),
     ValueRef(&'a Value),
     Expr(ExprKind<Value, Normalized>),
@@ -589,7 +589,7 @@ fn apply_binop<'a>(
 pub(crate) fn normalize_one_layer(
     expr: ExprKind<Value, Normalized>,
     ty: &Value,
-) -> ValueKind {
+) -> ValueKind<Value> {
     use ValueKind::{
         AppliedBuiltin, BoolLit, DoubleLit, EmptyListLit, EmptyOptionalLit,
         IntegerLit, NEListLit, NEOptionalLit, NaturalLit, RecordLit, TextLit,
@@ -779,7 +779,10 @@ pub(crate) fn normalize_one_layer(
 }
 
 /// Normalize a ValueKind into WHNF
-pub(crate) fn normalize_whnf(v: ValueKind, ty: &Value) -> ValueKind {
+pub(crate) fn normalize_whnf(
+    v: ValueKind<Value>,
+    ty: &Value,
+) -> ValueKind<Value> {
     match v {
         ValueKind::AppliedBuiltin(b, args) => apply_builtin(b, args, ty),
         ValueKind::PartialExpr(e) => normalize_one_layer(e, ty),
diff --git a/dhall/src/semantics/to_expr.rs b/dhall/src/semantics/to_expr.rs
index b21fb29..9dee7b5 100644
--- a/dhall/src/semantics/to_expr.rs
+++ b/dhall/src/semantics/to_expr.rs
@@ -27,7 +27,7 @@ pub(crate) fn value_to_expr(
 
 /// Converts a value back to the corresponding AST expression.
 pub(crate) fn kind_to_expr(
-    kind: &ValueKind,
+    kind: &ValueKind<Value>,
     opts: ToExprOptions,
 ) -> NormalizedExpr {
     match kind {
-- 
cgit v1.2.3


From 8e2da26650e202f9ccb1531fc8a88cfd89e54b6d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 27 Dec 2019 15:15:08 +0000
Subject: Implement traverse_ref for ValueKind

---
 dhall/src/semantics/core/mod.rs     |   3 +
 dhall/src/semantics/core/value.rs   |  28 ++++++++
 dhall/src/semantics/core/visitor.rs | 134 ++++++++++++++++++++++++++++++++++++
 dhall/src/semantics/mod.rs          |   1 +
 dhall/src/syntax/ast/expr.rs        |   2 +-
 dhall/src/syntax/ast/visitor.rs     |   3 +-
 6 files changed, 169 insertions(+), 2 deletions(-)
 create mode 100644 dhall/src/semantics/core/visitor.rs

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/mod.rs b/dhall/src/semantics/core/mod.rs
index 90d74ea..6f577f0 100644
--- a/dhall/src/semantics/core/mod.rs
+++ b/dhall/src/semantics/core/mod.rs
@@ -1,3 +1,6 @@
 pub mod context;
 pub mod value;
 pub mod var;
+pub mod visitor;
+pub(crate) use value::*;
+pub(crate) use var::*;
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 5f244b7..f7c2fbf 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -388,6 +388,34 @@ impl ValueKind<Value> {
     }
 }
 
+impl<V> ValueKind<V> {
+    #[allow(dead_code)]
+    pub(crate) fn map_ref_with_special_handling_of_binders<'a, V2>(
+        &'a self,
+        mut map_val: impl FnMut(&'a V) -> V2,
+        mut map_under_binder: impl FnMut(&'a AlphaLabel, &'a V) -> V2,
+    ) -> ValueKind<V2> {
+        use crate::semantics::visitor;
+        use crate::syntax::trivial_result;
+        use visitor::ValueKindVisitor;
+        trivial_result(
+            visitor::TraverseRefWithBindersVisitor {
+                visit_val: |x| Ok(map_val(x)),
+                visit_under_binder: |l, x| Ok(map_under_binder(l, x)),
+            }
+            .visit(self),
+        )
+    }
+}
+
+// #[allow(dead_code)]
+// fn equiv(x: &Value, y:&Value) -> bool {
+//     let map = |kind| {
+
+//     };
+//     map(x) == map(y)
+// }
+
 impl Shift for Value {
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
         Some(Value(self.0.shift(delta, var)?))
diff --git a/dhall/src/semantics/core/visitor.rs b/dhall/src/semantics/core/visitor.rs
new file mode 100644
index 0000000..c7cf79e
--- /dev/null
+++ b/dhall/src/semantics/core/visitor.rs
@@ -0,0 +1,134 @@
+use std::iter::FromIterator;
+
+use crate::semantics::{AlphaLabel, ValueKind};
+use crate::syntax::Label;
+
+/// A visitor trait that can be used to traverse `ValueKind`s. We need this pattern so that Rust lets
+/// us have as much mutability as we can. See the equivalent file in `crate::syntax` for more
+/// details.
+pub(crate) trait ValueKindVisitor<'a, V1, V2>: Sized {
+    type Error;
+
+    fn visit_val(&mut self, val: &'a V1) -> Result<V2, Self::Error>;
+    fn visit_val_under_binder(
+        mut self,
+        _label: &'a AlphaLabel,
+        val: &'a V1,
+    ) -> Result<V2, Self::Error> {
+        self.visit_val(val)
+    }
+    fn visit_vec(&mut self, x: &'a [V1]) -> Result<Vec<V2>, Self::Error> {
+        x.iter().map(|e| self.visit_val(e)).collect()
+    }
+    fn visit_opt(
+        &mut self,
+        x: &'a Option<V1>,
+    ) -> Result<Option<V2>, Self::Error> {
+        Ok(match x {
+            Some(x) => Some(self.visit_val(x)?),
+            None => None,
+        })
+    }
+    fn visit_map<T>(
+        &mut self,
+        x: impl IntoIterator<Item = (&'a Label, &'a V1)>,
+    ) -> Result<T, Self::Error>
+    where
+        V1: 'a,
+        T: FromIterator<(Label, V2)>,
+    {
+        x.into_iter()
+            .map(|(k, x)| Ok((k.clone(), self.visit_val(x)?)))
+            .collect()
+    }
+    fn visit_optmap<T>(
+        &mut self,
+        x: impl IntoIterator<Item = (&'a Label, &'a Option<V1>)>,
+    ) -> Result<T, Self::Error>
+    where
+        V1: 'a,
+        T: FromIterator<(Label, Option<V2>)>,
+    {
+        x.into_iter()
+            .map(|(k, x)| Ok((k.clone(), self.visit_opt(x)?)))
+            .collect()
+    }
+
+    fn visit(
+        self,
+        input: &'a ValueKind<V1>,
+    ) -> Result<ValueKind<V2>, Self::Error> {
+        visit_ref(self, input)
+    }
+}
+
+fn visit_ref<'a, Visitor, V1, V2>(
+    mut v: Visitor,
+    input: &'a ValueKind<V1>,
+) -> Result<ValueKind<V2>, Visitor::Error>
+where
+    Visitor: ValueKindVisitor<'a, V1, V2>,
+{
+    use ValueKind::*;
+    Ok(match input {
+        Lam(l, t, e) => {
+            Lam(l.clone(), v.visit_val(t)?, v.visit_val_under_binder(l, e)?)
+        }
+        Pi(l, t, e) => {
+            Pi(l.clone(), v.visit_val(t)?, v.visit_val_under_binder(l, e)?)
+        }
+        AppliedBuiltin(b, xs) => AppliedBuiltin(*b, v.visit_vec(xs)?),
+        Var(v) => Var(v.clone()),
+        Const(k) => Const(*k),
+        BoolLit(b) => BoolLit(*b),
+        NaturalLit(n) => NaturalLit(*n),
+        IntegerLit(n) => IntegerLit(*n),
+        DoubleLit(n) => DoubleLit(*n),
+        EmptyOptionalLit(t) => EmptyOptionalLit(v.visit_val(t)?),
+        NEOptionalLit(x) => NEOptionalLit(v.visit_val(x)?),
+        EmptyListLit(t) => EmptyListLit(v.visit_val(t)?),
+        NEListLit(xs) => NEListLit(v.visit_vec(xs)?),
+        RecordType(kts) => RecordType(v.visit_map(kts)?),
+        RecordLit(kvs) => RecordLit(v.visit_map(kvs)?),
+        UnionType(kts) => UnionType(v.visit_optmap(kts)?),
+        UnionConstructor(l, kts) => {
+            UnionConstructor(l.clone(), v.visit_optmap(kts)?)
+        }
+        UnionLit(l, t, kts) => {
+            UnionLit(l.clone(), v.visit_val(t)?, v.visit_optmap(kts)?)
+        }
+        TextLit(ts) => TextLit(
+            ts.iter()
+                .map(|t| t.traverse_ref(|e| v.visit_val(e)))
+                .collect::<Result<_, _>>()?,
+        ),
+        Equivalence(x, y) => Equivalence(v.visit_val(x)?, v.visit_val(y)?),
+        PartialExpr(e) => PartialExpr(e.traverse_ref(|e| v.visit_val(e))?),
+    })
+}
+
+pub struct TraverseRefWithBindersVisitor<F1, F2> {
+    pub visit_val: F1,
+    pub visit_under_binder: F2,
+}
+
+impl<'a, V1, V2, Err, F1, F2> ValueKindVisitor<'a, V1, V2>
+    for TraverseRefWithBindersVisitor<F1, F2>
+where
+    V1: 'a,
+    F1: FnMut(&'a V1) -> Result<V2, Err>,
+    F2: FnOnce(&'a AlphaLabel, &'a V1) -> Result<V2, Err>,
+{
+    type Error = Err;
+
+    fn visit_val(&mut self, val: &'a V1) -> Result<V2, Self::Error> {
+        (self.visit_val)(val)
+    }
+    fn visit_val_under_binder(
+        self,
+        label: &'a AlphaLabel,
+        val: &'a V1,
+    ) -> Result<V2, Self::Error> {
+        (self.visit_under_binder)(label, val)
+    }
+}
diff --git a/dhall/src/semantics/mod.rs b/dhall/src/semantics/mod.rs
index 1eeef86..3ef1aba 100644
--- a/dhall/src/semantics/mod.rs
+++ b/dhall/src/semantics/mod.rs
@@ -1,3 +1,4 @@
 pub mod core;
 pub mod phase;
 pub mod to_expr;
+pub(crate) use self::core::*;
diff --git a/dhall/src/syntax/ast/expr.rs b/dhall/src/syntax/ast/expr.rs
index 68cb524..376480f 100644
--- a/dhall/src/syntax/ast/expr.rs
+++ b/dhall/src/syntax/ast/expr.rs
@@ -189,7 +189,7 @@ impl<SE, E> ExprKind<SE, E> {
         .visit(self)
     }
 
-    fn traverse_ref<'a, SE2, Err>(
+    pub(crate) fn traverse_ref<'a, SE2, Err>(
         &'a self,
         visit_subexpr: impl FnMut(&'a SE) -> Result<SE2, Err>,
     ) -> Result<ExprKind<SE2, E>, Err>
diff --git a/dhall/src/syntax/ast/visitor.rs b/dhall/src/syntax/ast/visitor.rs
index 424048b..f9fd379 100644
--- a/dhall/src/syntax/ast/visitor.rs
+++ b/dhall/src/syntax/ast/visitor.rs
@@ -1,6 +1,7 @@
-use crate::syntax::*;
 use std::iter::FromIterator;
 
+use crate::syntax::*;
+
 /// A visitor trait that can be used to traverse `ExprKind`s. We need this pattern so that Rust lets
 /// us have as much mutability as we can.
 /// For example, `traverse_ref_with_special_handling_of_binders` cannot be made using only
-- 
cgit v1.2.3


From 654d752c65f0e221d225ed045a0aee62f223855e Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 27 Dec 2019 16:05:47 +0000
Subject: Introduce a notion of binder

---
 dhall/src/semantics/core/context.rs    | 25 +++++++++++++++++--------
 dhall/src/semantics/core/value.rs      |  8 ++++----
 dhall/src/semantics/core/var.rs        | 34 +++++++++++++++++-----------------
 dhall/src/semantics/core/visitor.rs    |  8 ++++----
 dhall/src/semantics/phase/typecheck.rs | 27 ++++++++++++++-------------
 5 files changed, 56 insertions(+), 46 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index ed63b63..3a7930e 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use crate::error::TypeError;
 use crate::semantics::core::value::Value;
 use crate::semantics::core::value::ValueKind;
-use crate::semantics::core::var::{AlphaVar, Shift, Subst};
+use crate::semantics::core::var::{AlphaVar, Binder, Shift, Subst};
 use crate::syntax::{Label, V};
 
 #[derive(Debug, Clone)]
@@ -14,22 +14,26 @@ enum CtxItem {
 
 #[derive(Debug, Clone)]
 pub(crate) struct TyCtx {
-    ctx: Vec<(Label, CtxItem)>,
+    ctx: Vec<(Binder, CtxItem)>,
 }
 
 impl TyCtx {
     pub fn new() -> Self {
         TyCtx { ctx: Vec::new() }
     }
-    fn with_vec(&self, vec: Vec<(Label, CtxItem)>) -> Self {
+    fn with_vec(&self, vec: Vec<(Binder, CtxItem)>) -> Self {
         TyCtx { ctx: vec }
     }
-    pub fn insert_type(&self, x: &Label, t: Value) -> Self {
+    pub fn insert_type(&self, x: &Binder, t: Value) -> Self {
         let mut vec = self.ctx.clone();
         vec.push((x.clone(), CtxItem::Kept(x.into(), t.under_binder(x))));
         self.with_vec(vec)
     }
-    pub fn insert_value(&self, x: &Label, e: Value) -> Result<Self, TypeError> {
+    pub fn insert_value(
+        &self,
+        x: &Binder,
+        e: Value,
+    ) -> Result<Self, TypeError> {
         let mut vec = self.ctx.clone();
         vec.push((x.clone(), CtxItem::Replaced(e)));
         Ok(self.with_vec(vec))
@@ -37,8 +41,9 @@ impl TyCtx {
     pub fn lookup(&self, var: &V<Label>) -> Option<Value> {
         let mut var = var.clone();
         let mut shift_map: HashMap<Label, _> = HashMap::new();
-        for (l, i) in self.ctx.iter().rev() {
-            match var.over_binder(l) {
+        for (b, i) in self.ctx.iter().rev() {
+            let l = b.to_label();
+            match var.over_binder(&l) {
                 None => {
                     let i = i.under_multiple_binders(&shift_map);
                     return Some(match i {
@@ -51,12 +56,16 @@ impl TyCtx {
                 Some(newvar) => var = newvar,
             };
             if let CtxItem::Kept(_, _) = i {
-                *shift_map.entry(l.clone()).or_insert(0) += 1;
+                *shift_map.entry(l).or_insert(0) += 1;
             }
         }
         // Unbound variable
         None
     }
+    pub fn new_binder(&self, l: &Label) -> Binder {
+        Binder::new(l.clone())
+    }
+
     /// Given a var that makes sense in the current context, map the given function in such a way
     /// that the passed variable always makes sense in the context of the passed item.
     /// Once we pass the variable definition, the variable doesn't make sense anymore so we just
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index f7c2fbf..687fcfe 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -4,7 +4,7 @@ use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::context::TyCtx;
-use crate::semantics::core::var::{AlphaLabel, AlphaVar, Shift, Subst};
+use crate::semantics::core::var::{AlphaVar, Binder, Shift, Subst};
 use crate::semantics::phase::normalize::{apply_any, normalize_whnf};
 use crate::semantics::phase::typecheck::{builtin_to_value, const_to_value};
 use crate::semantics::phase::{Normalized, NormalizedExpr, Typed};
@@ -54,8 +54,8 @@ pub(crate) enum Form {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum ValueKind<Value> {
     /// Closures
-    Lam(AlphaLabel, Value, Value),
-    Pi(AlphaLabel, Value, Value),
+    Lam(Binder, Value, Value),
+    Pi(Binder, Value, Value),
     // Invariant: in whnf, the evaluation must not be able to progress further.
     AppliedBuiltin(Builtin, Vec<Value>),
 
@@ -393,7 +393,7 @@ impl<V> ValueKind<V> {
     pub(crate) fn map_ref_with_special_handling_of_binders<'a, V2>(
         &'a self,
         mut map_val: impl FnMut(&'a V) -> V2,
-        mut map_under_binder: impl FnMut(&'a AlphaLabel, &'a V) -> V2,
+        mut map_under_binder: impl FnMut(&'a Binder, &'a V) -> V2,
     ) -> ValueKind<V2> {
         use crate::semantics::visitor;
         use crate::syntax::trivial_result;
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index 017a689..add0500 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -14,7 +14,9 @@ pub struct AlphaVar {
 // Exactly like a Label, but equality returns always true.
 // This is so that ValueKind equality is exactly alpha-equivalence.
 #[derive(Clone, Eq)]
-pub struct AlphaLabel(Label);
+pub struct Binder {
+    name: Label,
+}
 
 pub(crate) trait Shift: Sized {
     // Shift an expression to move it around binders without changing the meaning of its free
@@ -64,7 +66,10 @@ impl AlphaVar {
     }
 }
 
-impl AlphaLabel {
+impl Binder {
+    pub(crate) fn new(name: Label) -> Self {
+        Binder { name }
+    }
     pub(crate) fn to_label_maybe_alpha(&self, alpha: bool) -> Label {
         if alpha {
             "_".into()
@@ -92,7 +97,7 @@ impl std::cmp::PartialEq for AlphaVar {
         self.alpha == other.alpha
     }
 }
-impl std::cmp::PartialEq for AlphaLabel {
+impl std::cmp::PartialEq for Binder {
     fn eq(&self, _other: &Self) -> bool {
         true
     }
@@ -104,9 +109,9 @@ impl std::fmt::Debug for AlphaVar {
     }
 }
 
-impl std::fmt::Debug for AlphaLabel {
+impl std::fmt::Debug for Binder {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "AlphaLabel({})", &self.0)
+        write!(f, "Binder({})", &self.name)
     }
 }
 
@@ -123,26 +128,21 @@ impl<'a> From<&'a Label> for AlphaVar {
         x.clone().into()
     }
 }
-impl From<AlphaLabel> for AlphaVar {
-    fn from(x: AlphaLabel) -> AlphaVar {
+impl From<Binder> for AlphaVar {
+    fn from(x: Binder) -> AlphaVar {
         let l: Label = x.into();
         l.into()
     }
 }
-impl<'a> From<&'a AlphaLabel> for AlphaVar {
-    fn from(x: &'a AlphaLabel) -> AlphaVar {
+impl<'a> From<&'a Binder> for AlphaVar {
+    fn from(x: &'a Binder) -> AlphaVar {
         x.clone().into()
     }
 }
 
-impl From<Label> for AlphaLabel {
-    fn from(x: Label) -> AlphaLabel {
-        AlphaLabel(x)
-    }
-}
-impl From<AlphaLabel> for Label {
-    fn from(x: AlphaLabel) -> Label {
-        x.0
+impl From<Binder> for Label {
+    fn from(x: Binder) -> Label {
+        x.name
     }
 }
 impl Shift for () {
diff --git a/dhall/src/semantics/core/visitor.rs b/dhall/src/semantics/core/visitor.rs
index c7cf79e..2c9ba92 100644
--- a/dhall/src/semantics/core/visitor.rs
+++ b/dhall/src/semantics/core/visitor.rs
@@ -1,6 +1,6 @@
 use std::iter::FromIterator;
 
-use crate::semantics::{AlphaLabel, ValueKind};
+use crate::semantics::{Binder, ValueKind};
 use crate::syntax::Label;
 
 /// A visitor trait that can be used to traverse `ValueKind`s. We need this pattern so that Rust lets
@@ -12,7 +12,7 @@ pub(crate) trait ValueKindVisitor<'a, V1, V2>: Sized {
     fn visit_val(&mut self, val: &'a V1) -> Result<V2, Self::Error>;
     fn visit_val_under_binder(
         mut self,
-        _label: &'a AlphaLabel,
+        _label: &'a Binder,
         val: &'a V1,
     ) -> Result<V2, Self::Error> {
         self.visit_val(val)
@@ -117,7 +117,7 @@ impl<'a, V1, V2, Err, F1, F2> ValueKindVisitor<'a, V1, V2>
 where
     V1: 'a,
     F1: FnMut(&'a V1) -> Result<V2, Err>,
-    F2: FnOnce(&'a AlphaLabel, &'a V1) -> Result<V2, Err>,
+    F2: FnOnce(&'a Binder, &'a V1) -> Result<V2, Err>,
 {
     type Error = Err;
 
@@ -126,7 +126,7 @@ where
     }
     fn visit_val_under_binder(
         self,
-        label: &'a AlphaLabel,
+        label: &'a Binder,
         val: &'a V1,
     ) -> Result<V2, Self::Error> {
         (self.visit_under_binder)(label, val)
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index 2e1cc02..926598d 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -4,11 +4,9 @@ use std::collections::HashMap;
 
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::context::TyCtx;
-use crate::semantics::core::value::Value;
-use crate::semantics::core::value::ValueKind;
-use crate::semantics::core::var::{Shift, Subst};
 use crate::semantics::phase::normalize::merge_maps;
 use crate::semantics::phase::Normalized;
+use crate::semantics::{Binder, Shift, Subst, Value, ValueKind};
 use crate::syntax;
 use crate::syntax::{
     Builtin, Const, Expr, ExprKind, InterpolatedTextContents, Label, Span,
@@ -17,12 +15,12 @@ use crate::syntax::{
 
 fn tck_pi_type(
     ctx: &TyCtx,
-    x: Label,
+    binder: Binder,
     tx: Value,
     te: Value,
 ) -> Result<Value, TypeError> {
     use TypeMessage::*;
-    let ctx2 = ctx.insert_type(&x, tx.clone());
+    let ctx2 = ctx.insert_type(&binder, tx.clone());
 
     let ka = match tx.get_type()?.as_const() {
         Some(k) => k,
@@ -42,7 +40,7 @@ fn tck_pi_type(
     let k = function_check(ka, kb);
 
     Ok(Value::from_kind_and_type(
-        ValueKind::Pi(x.into(), tx, te),
+        ValueKind::Pi(binder, tx, te),
         Value::from_const(k),
     ))
 }
@@ -307,21 +305,23 @@ fn type_with(ctx: &TyCtx, e: Expr<Normalized>) -> Result<Value, TypeError> {
 
     match e.as_ref() {
         Lam(var, annot, body) => {
+            let binder = ctx.new_binder(var);
             let annot = type_with(ctx, annot.clone())?;
             annot.normalize_nf();
-            let ctx2 = ctx.insert_type(var, annot.clone());
+            let ctx2 = ctx.insert_type(&binder, annot.clone());
             let body = type_with(&ctx2, body.clone())?;
             let body_type = body.get_type()?;
             Ok(Value::from_kind_and_type(
-                ValueKind::Lam(var.clone().into(), annot.clone(), body),
-                tck_pi_type(ctx, var.clone(), annot, body_type)?,
+                ValueKind::Lam(binder.clone(), annot.clone(), body),
+                tck_pi_type(ctx, binder, annot, body_type)?,
             ))
         }
         Pi(x, ta, tb) => {
+            let binder = ctx.new_binder(x);
             let ta = type_with(ctx, ta.clone())?;
-            let ctx2 = ctx.insert_type(x, ta.clone());
+            let ctx2 = ctx.insert_type(&binder, ta.clone());
             let tb = type_with(&ctx2, tb.clone())?;
-            tck_pi_type(ctx, x.clone(), ta, tb)
+            tck_pi_type(ctx, binder, ta, tb)
         }
         Let(x, t, v, e) => {
             let v = if let Some(t) = t {
@@ -331,7 +331,8 @@ fn type_with(ctx: &TyCtx, e: Expr<Normalized>) -> Result<Value, TypeError> {
             };
 
             let v = type_with(ctx, v)?;
-            type_with(&ctx.insert_value(x, v.clone())?, e.clone())
+            let binder = ctx.new_binder(x);
+            type_with(&ctx.insert_value(&binder, v.clone())?, e.clone())
         }
         Embed(p) => Ok(p.clone().into_typed().into_value()),
         Var(var) => match ctx.lookup(&var) {
@@ -496,7 +497,7 @@ fn type_last_layer(
                                 RetTypeOnly(
                                     tck_pi_type(
                                         ctx,
-                                        x.clone(),
+                                        ctx.new_binder(x),
                                         t.clone(),
                                         r.under_binder(x),
                                     )?
-- 
cgit v1.2.3


From bc3599b815c6f9cad2f4efd30c009cbe8f765ca1 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 27 Dec 2019 17:03:43 +0000
Subject: Assign a unique id to each binder

---
 dhall/src/semantics/core/context.rs | 20 +++++++++++++++++---
 dhall/src/semantics/core/var.rs     | 10 ++++++++--
 2 files changed, 25 insertions(+), 5 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index 3a7930e..25e4037 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -1,4 +1,6 @@
+use std::cell::RefCell;
 use std::collections::HashMap;
+use std::rc::Rc;
 
 use crate::error::TypeError;
 use crate::semantics::core::value::Value;
@@ -15,14 +17,23 @@ enum CtxItem {
 #[derive(Debug, Clone)]
 pub(crate) struct TyCtx {
     ctx: Vec<(Binder, CtxItem)>,
+    /// Keeps track of the next free binder id to assign. Shared among all the contexts to ensure
+    /// unicity across the expression.
+    next_uid: Rc<RefCell<u64>>,
 }
 
 impl TyCtx {
     pub fn new() -> Self {
-        TyCtx { ctx: Vec::new() }
+        TyCtx {
+            ctx: Vec::new(),
+            next_uid: Rc::new(RefCell::new(0)),
+        }
     }
     fn with_vec(&self, vec: Vec<(Binder, CtxItem)>) -> Self {
-        TyCtx { ctx: vec }
+        TyCtx {
+            ctx: vec,
+            next_uid: self.next_uid.clone(),
+        }
     }
     pub fn insert_type(&self, x: &Binder, t: Value) -> Self {
         let mut vec = self.ctx.clone();
@@ -63,7 +74,10 @@ impl TyCtx {
         None
     }
     pub fn new_binder(&self, l: &Label) -> Binder {
-        Binder::new(l.clone())
+        let mut next_uid = self.next_uid.borrow_mut();
+        let uid = *next_uid;
+        *next_uid += 1;
+        Binder::new(l.clone(), uid)
     }
 
     /// Given a var that makes sense in the current context, map the given function in such a way
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index add0500..28ddadd 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -11,11 +11,17 @@ pub struct AlphaVar {
     alpha: V<()>,
 }
 
+type BinderUID = u64;
+
 // Exactly like a Label, but equality returns always true.
 // This is so that ValueKind equality is exactly alpha-equivalence.
 #[derive(Clone, Eq)]
 pub struct Binder {
     name: Label,
+    /// Id of the binder, unique across the current expression. Used to distinguish bindersinstead
+    /// of their name. The id won't actually be unique when there are imports around, but
+    /// typechecking ensures this can't cause a conflict.
+    uid: BinderUID,
 }
 
 pub(crate) trait Shift: Sized {
@@ -67,8 +73,8 @@ impl AlphaVar {
 }
 
 impl Binder {
-    pub(crate) fn new(name: Label) -> Self {
-        Binder { name }
+    pub(crate) fn new(name: Label, uid: BinderUID) -> Self {
+        Binder { name, uid }
     }
     pub(crate) fn to_label_maybe_alpha(&self, alpha: bool) -> Label {
         if alpha {
-- 
cgit v1.2.3


From 8cbec8c75d9e52091bdfe28b60b6ee698d9c1392 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 27 Dec 2019 17:23:21 +0000
Subject: Store corresponding binder id in AlphaVar

---
 dhall/src/semantics/core/var.rs        | 24 ++++++++++++++----------
 dhall/src/semantics/phase/typecheck.rs |  3 ++-
 2 files changed, 16 insertions(+), 11 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index 28ddadd..98b315e 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -9,6 +9,8 @@ use crate::syntax::{ExprKind, InterpolatedTextContents, Label, V};
 pub struct AlphaVar {
     normal: V<Label>,
     alpha: V<()>,
+    /// Id of the corresponding binder.
+    binder_uid: BinderUID,
 }
 
 type BinderUID = u64;
@@ -93,6 +95,7 @@ impl Shift for AlphaVar {
         Some(AlphaVar {
             normal: self.normal.shift(delta, &var.normal)?,
             alpha: self.alpha.shift(delta, &var.alpha)?,
+            binder_uid: self.binder_uid,
         })
     }
 }
@@ -121,23 +124,24 @@ impl std::fmt::Debug for Binder {
     }
 }
 
-impl From<Label> for AlphaVar {
-    fn from(x: Label) -> AlphaVar {
+impl<'a> From<&'a Label> for AlphaVar {
+    fn from(x: &'a Label) -> AlphaVar {
         AlphaVar {
-            normal: V(x, 0),
+            normal: V(x.clone(), 0),
             alpha: V((), 0),
+            // TODO: evil evil but only used in shift
+            binder_uid: 0,
         }
     }
 }
-impl<'a> From<&'a Label> for AlphaVar {
-    fn from(x: &'a Label) -> AlphaVar {
-        x.clone().into()
-    }
-}
 impl From<Binder> for AlphaVar {
     fn from(x: Binder) -> AlphaVar {
-        let l: Label = x.into();
-        l.into()
+        let binder_uid = x.uid;
+        AlphaVar {
+            normal: V(x.into(), 0),
+            alpha: V((), 0),
+            binder_uid,
+        }
     }
 }
 impl<'a> From<&'a Binder> for AlphaVar {
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index 926598d..7e408eb 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -494,10 +494,11 @@ fn type_last_layer(
                         ValueKind::UnionType(kts) => match kts.get(&x) {
                             // Constructor has type T -> < x: T, ... >
                             Some(Some(t)) => {
+                                let x = ctx.new_binder(x);
                                 RetTypeOnly(
                                     tck_pi_type(
                                         ctx,
-                                        ctx.new_binder(x),
+                                        x.clone(),
                                         t.clone(),
                                         r.under_binder(x),
                                     )?
-- 
cgit v1.2.3


From 4dc195c8d8a2ef03621fb73d15df2c66ad68be2c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 27 Dec 2019 18:28:33 +0000
Subject: Use binder ids for Value equality

---
 dhall/src/semantics/core/value.rs | 76 ++++++++++++++++++++++++++++++++++-----
 dhall/src/semantics/core/var.rs   |  6 ++++
 2 files changed, 74 insertions(+), 8 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 687fcfe..9b64bd2 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::cell::{Ref, RefCell, RefMut};
 use std::collections::HashMap;
 use std::rc::Rc;
@@ -408,13 +409,73 @@ impl<V> ValueKind<V> {
     }
 }
 
-// #[allow(dead_code)]
-// fn equiv(x: &Value, y:&Value) -> bool {
-//     let map = |kind| {
+/// Compare two values for equality modulo alpha/beta-equivalence.
+// TODO: use Rc comparison to shortcut on identical pointers
+fn equiv(val1: &Value, val2: &Value) -> bool {
+    struct ValueWithCtx<'v, 'c> {
+        val: &'v Value,
+        ctx: Cow<'c, Vec<&'v Binder>>,
+    }
+    impl<'v, 'c> PartialEq for ValueWithCtx<'v, 'c> {
+        fn eq(&self, other: &ValueWithCtx<'v, 'c>) -> bool {
+            equiv_with_ctx(&*self.ctx, self.val, &*other.ctx, other.val)
+        }
+    }
+    // Push the given context into every subnode of the ValueKind. That way, normal equality of the
+    // resulting value will take into account the context.
+    fn push_context<'v, 'c>(
+        ctx: &'c Vec<&'v Binder>,
+        kind: &'v ValueKind<Value>,
+    ) -> ValueKind<ValueWithCtx<'v, 'c>> {
+        kind.map_ref_with_special_handling_of_binders(
+            |val| ValueWithCtx {
+                val,
+                ctx: Cow::Borrowed(ctx),
+            },
+            |binder, val| ValueWithCtx {
+                val,
+                ctx: Cow::Owned(
+                    ctx.iter().cloned().chain(Some(binder)).collect(),
+                ),
+            },
+        )
+    }
+
+    fn lookup(ctx: &Vec<&Binder>, binder: &Binder) -> Option<usize> {
+        ctx.iter()
+            .rev()
+            .enumerate()
+            .find(|(_, other)| binder.same_binder(other))
+            .map(|(i, _)| i)
+    }
 
-//     };
-//     map(x) == map(y)
-// }
+    fn equiv_with_ctx<'v, 'c>(
+        ctx1: &'c Vec<&'v Binder>,
+        val1: &'v Value,
+        ctx2: &'c Vec<&'v Binder>,
+        val2: &'v Value,
+    ) -> bool {
+        use ValueKind::Var;
+        let kind1 = val1.as_whnf();
+        let kind2 = val2.as_whnf();
+
+        if let (Var(v1), Var(v2)) = (&*kind1, &*kind2) {
+            let b1 = v1.binder();
+            let b2 = v2.binder();
+            if b1.same_binder(&b2) {
+                return true;
+            }
+            match (lookup(ctx1, &b1), lookup(ctx2, &b2)) {
+                (Some(i), Some(j)) => i == j,
+                _ => false,
+            }
+        } else {
+            push_context(ctx1, &*kind1) == push_context(ctx2, &*kind2)
+        }
+    }
+
+    equiv_with_ctx(&Vec::new(), val1, &Vec::new(), val2)
+}
 
 impl Shift for Value {
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
@@ -593,10 +654,9 @@ impl Subst<Value> for ValueKind<Value> {
     }
 }
 
-// TODO: use Rc comparison to shortcut on identical pointers
 impl std::cmp::PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {
-        *self.as_whnf() == *other.as_whnf()
+        equiv(self, other)
     }
 }
 impl std::cmp::Eq for Value {}
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index 98b315e..4245e40 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -72,12 +72,18 @@ impl AlphaVar {
             self.normal.clone()
         }
     }
+    pub(crate) fn binder(&self) -> Binder {
+        Binder::new(self.normal.0.clone(), self.binder_uid)
+    }
 }
 
 impl Binder {
     pub(crate) fn new(name: Label, uid: BinderUID) -> Self {
         Binder { name, uid }
     }
+    pub(crate) fn same_binder(&self, other: &Binder) -> bool {
+        self.uid == other.uid
+    }
     pub(crate) fn to_label_maybe_alpha(&self, alpha: bool) -> Label {
         if alpha {
             "_".into()
-- 
cgit v1.2.3


From 03da8fd6399f09c6282e0cd3930b6e39cc089043 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 27 Dec 2019 21:14:45 +0000
Subject: Simplify Value::to_expr

---
 dhall/src/semantics/core/value.rs |  18 +++---
 dhall/src/semantics/to_expr.rs    | 112 +++++++++++++++-----------------------
 2 files changed, 52 insertions(+), 78 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 9b64bd2..f8146f5 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -306,14 +306,6 @@ impl ValueKind<Value> {
         Value::from_kind_and_type(self, t)
     }
 
-    /// Converts a value back to the corresponding AST expression.
-    pub(crate) fn to_expr(
-        &self,
-        opts: to_expr::ToExprOptions,
-    ) -> NormalizedExpr {
-        to_expr::kind_to_expr(self, opts)
-    }
-
     pub(crate) fn normalize_mut(&mut self) {
         match self {
             ValueKind::Var(_)
@@ -390,7 +382,6 @@ impl ValueKind<Value> {
 }
 
 impl<V> ValueKind<V> {
-    #[allow(dead_code)]
     pub(crate) fn map_ref_with_special_handling_of_binders<'a, V2>(
         &'a self,
         mut map_val: impl FnMut(&'a V) -> V2,
@@ -407,6 +398,15 @@ impl<V> ValueKind<V> {
             .visit(self),
         )
     }
+
+    pub(crate) fn map_ref<'a, V2>(
+        &'a self,
+        map_val: impl Fn(&'a V) -> V2,
+    ) -> ValueKind<V2> {
+        self.map_ref_with_special_handling_of_binders(&map_val, |_, x| {
+            map_val(x)
+        })
+    }
 }
 
 /// Compare two values for equality modulo alpha/beta-equivalence.
diff --git a/dhall/src/semantics/to_expr.rs b/dhall/src/semantics/to_expr.rs
index 9dee7b5..11e289f 100644
--- a/dhall/src/semantics/to_expr.rs
+++ b/dhall/src/semantics/to_expr.rs
@@ -5,8 +5,8 @@ use crate::semantics::phase::NormalizedExpr;
 use crate::syntax;
 use crate::syntax::{Builtin, ExprKind};
 
-#[derive(Copy, Clone)]
 /// Controls conversion from `Value` to `Expr`
+#[derive(Copy, Clone)]
 pub(crate) struct ToExprOptions {
     /// Whether to convert all variables to `_`
     pub(crate) alpha: bool,
@@ -22,84 +22,58 @@ pub(crate) fn value_to_expr(
     if opts.normalize {
         val.normalize_whnf();
     }
-    val.as_kind().to_expr(opts)
-}
 
-/// Converts a value back to the corresponding AST expression.
-pub(crate) fn kind_to_expr(
-    kind: &ValueKind<Value>,
-    opts: ToExprOptions,
-) -> NormalizedExpr {
-    match kind {
-        ValueKind::Lam(x, t, e) => rc(ExprKind::Lam(
-            x.to_label_maybe_alpha(opts.alpha),
-            t.to_expr(opts),
-            e.to_expr(opts),
-        )),
+    match val.as_kind().map_ref(|v| value_to_expr(v, opts)) {
+        ValueKind::Lam(x, t, e) => {
+            rc(ExprKind::Lam(x.to_label_maybe_alpha(opts.alpha), t, e))
+        }
         ValueKind::AppliedBuiltin(b, args) => args
-            .iter()
-            .map(|v| v.to_expr(opts))
-            .fold(rc(ExprKind::Builtin(*b)), |acc, v| {
-                rc(ExprKind::App(acc, v))
-            }),
-        ValueKind::Pi(x, t, e) => rc(ExprKind::Pi(
-            x.to_label_maybe_alpha(opts.alpha),
-            t.to_expr(opts),
-            e.to_expr(opts),
-        )),
+            .into_iter()
+            .fold(rc(ExprKind::Builtin(b)), |acc, v| rc(ExprKind::App(acc, v))),
+        ValueKind::Pi(x, t, e) => {
+            rc(ExprKind::Pi(x.to_label_maybe_alpha(opts.alpha), t, e))
+        }
         ValueKind::Var(v) => rc(ExprKind::Var(v.to_var(opts.alpha))),
-        ValueKind::Const(c) => rc(ExprKind::Const(*c)),
-        ValueKind::BoolLit(b) => rc(ExprKind::BoolLit(*b)),
-        ValueKind::NaturalLit(n) => rc(ExprKind::NaturalLit(*n)),
-        ValueKind::IntegerLit(n) => rc(ExprKind::IntegerLit(*n)),
-        ValueKind::DoubleLit(n) => rc(ExprKind::DoubleLit(*n)),
+        ValueKind::Const(c) => rc(ExprKind::Const(c)),
+        ValueKind::BoolLit(b) => rc(ExprKind::BoolLit(b)),
+        ValueKind::NaturalLit(n) => rc(ExprKind::NaturalLit(n)),
+        ValueKind::IntegerLit(n) => rc(ExprKind::IntegerLit(n)),
+        ValueKind::DoubleLit(n) => rc(ExprKind::DoubleLit(n)),
         ValueKind::EmptyOptionalLit(n) => rc(ExprKind::App(
             rc(ExprKind::Builtin(Builtin::OptionalNone)),
-            n.to_expr(opts),
+            n,
         )),
-        ValueKind::NEOptionalLit(n) => rc(ExprKind::SomeLit(n.to_expr(opts))),
-        ValueKind::EmptyListLit(n) => {
-            rc(ExprKind::EmptyListLit(rc(ExprKind::App(
-                rc(ExprKind::Builtin(Builtin::List)),
-                n.to_expr(opts),
-            ))))
+        ValueKind::NEOptionalLit(n) => rc(ExprKind::SomeLit(n)),
+        ValueKind::EmptyListLit(n) => rc(ExprKind::EmptyListLit(rc(
+            ExprKind::App(rc(ExprKind::Builtin(Builtin::List)), n),
+        ))),
+        ValueKind::NEListLit(elts) => rc(ExprKind::NEListLit(elts)),
+        ValueKind::RecordLit(kvs) => {
+            rc(ExprKind::RecordLit(kvs.into_iter().collect()))
+        }
+        ValueKind::RecordType(kts) => {
+            rc(ExprKind::RecordType(kts.into_iter().collect()))
+        }
+        ValueKind::UnionType(kts) => {
+            rc(ExprKind::UnionType(kts.into_iter().collect()))
         }
-        ValueKind::NEListLit(elts) => rc(ExprKind::NEListLit(
-            elts.iter().map(|n| n.to_expr(opts)).collect(),
-        )),
-        ValueKind::RecordLit(kvs) => rc(ExprKind::RecordLit(
-            kvs.iter()
-                .map(|(k, v)| (k.clone(), v.to_expr(opts)))
-                .collect(),
-        )),
-        ValueKind::RecordType(kts) => rc(ExprKind::RecordType(
-            kts.iter()
-                .map(|(k, v)| (k.clone(), v.to_expr(opts)))
-                .collect(),
-        )),
-        ValueKind::UnionType(kts) => rc(ExprKind::UnionType(
-            kts.iter()
-                .map(|(k, v)| (k.clone(), v.as_ref().map(|v| v.to_expr(opts))))
-                .collect(),
-        )),
         ValueKind::UnionConstructor(l, kts) => rc(ExprKind::Field(
-            ValueKind::UnionType(kts.clone()).to_expr(opts),
-            l.clone(),
+            rc(ExprKind::UnionType(kts.into_iter().collect())),
+            l,
         )),
         ValueKind::UnionLit(l, v, kts) => rc(ExprKind::App(
-            ValueKind::UnionConstructor(l.clone(), kts.clone()).to_expr(opts),
-            v.to_expr(opts),
-        )),
-        ValueKind::TextLit(elts) => rc(ExprKind::TextLit(
-            elts.iter()
-                .map(|contents| contents.map_ref(|e| e.to_expr(opts)))
-                .collect(),
-        )),
-        ValueKind::Equivalence(x, y) => rc(ExprKind::BinOp(
-            syntax::BinOp::Equivalence,
-            x.to_expr(opts),
-            y.to_expr(opts),
+            rc(ExprKind::Field(
+                rc(ExprKind::UnionType(kts.into_iter().collect())),
+                l,
+            )),
+            v,
         )),
-        ValueKind::PartialExpr(e) => rc(e.map_ref(|v| v.to_expr(opts))),
+        ValueKind::TextLit(elts) => {
+            rc(ExprKind::TextLit(elts.into_iter().collect()))
+        }
+        ValueKind::Equivalence(x, y) => {
+            rc(ExprKind::BinOp(syntax::BinOp::Equivalence, x, y))
+        }
+        ValueKind::PartialExpr(e) => rc(e),
     }
 }
-- 
cgit v1.2.3


From a030560e60c4ff1c724216f4a5640722eb89b227 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 27 Dec 2019 21:38:34 +0000
Subject: Use binder ids to reconstruct variables in expr output

---
 dhall/src/semantics/core/context.rs | 33 +++++++++++++++++++++++++++++++++
 dhall/src/semantics/core/value.rs   | 34 +++++++++++++---------------------
 dhall/src/semantics/core/var.rs     | 10 +++-------
 dhall/src/semantics/phase/mod.rs    |  8 +-------
 dhall/src/semantics/to_expr.rs      | 30 +++++++++++++++++++++++++-----
 5 files changed, 75 insertions(+), 40 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index 25e4037..826ba15 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -22,6 +22,11 @@ pub(crate) struct TyCtx {
     next_uid: Rc<RefCell<u64>>,
 }
 
+#[derive(Debug, Clone)]
+pub(crate) struct VarCtx<'b> {
+    ctx: Vec<&'b Binder>,
+}
+
 impl TyCtx {
     pub fn new() -> Self {
         TyCtx {
@@ -128,6 +133,34 @@ impl TyCtx {
     }
 }
 
+impl<'b> VarCtx<'b> {
+    pub fn new() -> Self {
+        VarCtx { ctx: Vec::new() }
+    }
+    pub fn insert(&self, binder: &'b Binder) -> Self {
+        VarCtx {
+            ctx: self.ctx.iter().copied().chain(Some(binder)).collect(),
+        }
+    }
+    pub fn lookup(&self, binder: &Binder) -> Option<usize> {
+        self.ctx
+            .iter()
+            .rev()
+            .enumerate()
+            .find(|(_, other)| binder.same_binder(other))
+            .map(|(i, _)| i)
+    }
+    pub fn lookup_by_name(&self, binder: &Binder) -> Option<usize> {
+        self.ctx
+            .iter()
+            .rev()
+            .filter(|other| binder.name() == other.name())
+            .enumerate()
+            .find(|(_, other)| binder.same_binder(other))
+            .map(|(i, _)| i)
+    }
+}
+
 impl Shift for CtxItem {
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
         Some(match self {
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index f8146f5..26b8672 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -4,7 +4,7 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
-use crate::semantics::core::context::TyCtx;
+use crate::semantics::core::context::{TyCtx, VarCtx};
 use crate::semantics::core::var::{AlphaVar, Binder, Shift, Subst};
 use crate::semantics::phase::normalize::{apply_any, normalize_whnf};
 use crate::semantics::phase::typecheck::{builtin_to_value, const_to_value};
@@ -164,7 +164,7 @@ impl Value {
         &self,
         opts: to_expr::ToExprOptions,
     ) -> NormalizedExpr {
-        to_expr::value_to_expr(self, opts)
+        to_expr::value_to_expr(&VarCtx::new(), self, opts)
     }
     pub(crate) fn to_whnf_ignore_type(&self) -> ValueKind<Value> {
         self.as_whnf().clone()
@@ -399,6 +399,7 @@ impl<V> ValueKind<V> {
         )
     }
 
+    #[allow(dead_code)]
     pub(crate) fn map_ref<'a, V2>(
         &'a self,
         map_val: impl Fn(&'a V) -> V2,
@@ -414,7 +415,7 @@ impl<V> ValueKind<V> {
 fn equiv(val1: &Value, val2: &Value) -> bool {
     struct ValueWithCtx<'v, 'c> {
         val: &'v Value,
-        ctx: Cow<'c, Vec<&'v Binder>>,
+        ctx: Cow<'c, VarCtx<'v>>,
     }
     impl<'v, 'c> PartialEq for ValueWithCtx<'v, 'c> {
         fn eq(&self, other: &ValueWithCtx<'v, 'c>) -> bool {
@@ -423,8 +424,8 @@ fn equiv(val1: &Value, val2: &Value) -> bool {
     }
     // Push the given context into every subnode of the ValueKind. That way, normal equality of the
     // resulting value will take into account the context.
-    fn push_context<'v, 'c>(
-        ctx: &'c Vec<&'v Binder>,
+    fn push_context_through<'v, 'c>(
+        ctx: &'c VarCtx<'v>,
         kind: &'v ValueKind<Value>,
     ) -> ValueKind<ValueWithCtx<'v, 'c>> {
         kind.map_ref_with_special_handling_of_binders(
@@ -434,25 +435,15 @@ fn equiv(val1: &Value, val2: &Value) -> bool {
             },
             |binder, val| ValueWithCtx {
                 val,
-                ctx: Cow::Owned(
-                    ctx.iter().cloned().chain(Some(binder)).collect(),
-                ),
+                ctx: Cow::Owned(ctx.insert(binder)),
             },
         )
     }
 
-    fn lookup(ctx: &Vec<&Binder>, binder: &Binder) -> Option<usize> {
-        ctx.iter()
-            .rev()
-            .enumerate()
-            .find(|(_, other)| binder.same_binder(other))
-            .map(|(i, _)| i)
-    }
-
     fn equiv_with_ctx<'v, 'c>(
-        ctx1: &'c Vec<&'v Binder>,
+        ctx1: &'c VarCtx<'v>,
         val1: &'v Value,
-        ctx2: &'c Vec<&'v Binder>,
+        ctx2: &'c VarCtx<'v>,
         val2: &'v Value,
     ) -> bool {
         use ValueKind::Var;
@@ -465,16 +456,17 @@ fn equiv(val1: &Value, val2: &Value) -> bool {
             if b1.same_binder(&b2) {
                 return true;
             }
-            match (lookup(ctx1, &b1), lookup(ctx2, &b2)) {
+            match (ctx1.lookup(&b1), ctx2.lookup(&b2)) {
                 (Some(i), Some(j)) => i == j,
                 _ => false,
             }
         } else {
-            push_context(ctx1, &*kind1) == push_context(ctx2, &*kind2)
+            push_context_through(ctx1, &*kind1)
+                == push_context_through(ctx2, &*kind2)
         }
     }
 
-    equiv_with_ctx(&Vec::new(), val1, &Vec::new(), val2)
+    equiv_with_ctx(&VarCtx::new(), val1, &VarCtx::new(), val2)
 }
 
 impl Shift for Value {
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index 4245e40..d21fa80 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -65,13 +65,6 @@ pub(crate) trait Subst<S> {
 }
 
 impl AlphaVar {
-    pub(crate) fn to_var(&self, alpha: bool) -> V<Label> {
-        if alpha {
-            V("_".into(), self.alpha.1)
-        } else {
-            self.normal.clone()
-        }
-    }
     pub(crate) fn binder(&self) -> Binder {
         Binder::new(self.normal.0.clone(), self.binder_uid)
     }
@@ -81,6 +74,9 @@ impl Binder {
     pub(crate) fn new(name: Label, uid: BinderUID) -> Self {
         Binder { name, uid }
     }
+    pub(crate) fn name(&self) -> &Label {
+        &self.name
+    }
     pub(crate) fn same_binder(&self, other: &Binder) -> bool {
         self.uid == other.uid
     }
diff --git a/dhall/src/semantics/phase/mod.rs b/dhall/src/semantics/phase/mod.rs
index 104a1ba..5d17338 100644
--- a/dhall/src/semantics/phase/mod.rs
+++ b/dhall/src/semantics/phase/mod.rs
@@ -4,7 +4,7 @@ use std::path::Path;
 use crate::error::{EncodeError, Error, ImportError, TypeError};
 use crate::semantics::core::value::Value;
 use crate::semantics::core::value::ValueKind;
-use crate::semantics::core::var::{AlphaVar, Shift, Subst};
+use crate::semantics::core::var::{AlphaVar, Shift};
 use crate::semantics::to_expr::ToExprOptions;
 use crate::syntax::binary;
 use crate::syntax::{Builtin, Const, Expr};
@@ -203,12 +203,6 @@ impl Shift for Normalized {
     }
 }
 
-impl Subst<Value> for Typed {
-    fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
-        Typed(self.0.subst_shift(var, val))
-    }
-}
-
 macro_rules! derive_traits_for_wrapper_struct {
     ($ty:ident) => {
         impl std::cmp::PartialEq for $ty {
diff --git a/dhall/src/semantics/to_expr.rs b/dhall/src/semantics/to_expr.rs
index 11e289f..1ece1cc 100644
--- a/dhall/src/semantics/to_expr.rs
+++ b/dhall/src/semantics/to_expr.rs
@@ -1,9 +1,9 @@
-use crate::semantics::core::value::Value;
-use crate::semantics::core::value::ValueKind;
+use crate::semantics::core::context::VarCtx;
 use crate::semantics::phase::typecheck::rc;
 use crate::semantics::phase::NormalizedExpr;
+use crate::semantics::{Value, ValueKind};
 use crate::syntax;
-use crate::syntax::{Builtin, ExprKind};
+use crate::syntax::{Builtin, ExprKind, V};
 
 /// Controls conversion from `Value` to `Expr`
 #[derive(Copy, Clone)]
@@ -16,6 +16,7 @@ pub(crate) struct ToExprOptions {
 
 /// Converts a value back to the corresponding AST expression.
 pub(crate) fn value_to_expr(
+    ctx: &VarCtx,
     val: &Value,
     opts: ToExprOptions,
 ) -> NormalizedExpr {
@@ -23,7 +24,27 @@ pub(crate) fn value_to_expr(
         val.normalize_whnf();
     }
 
-    match val.as_kind().map_ref(|v| value_to_expr(v, opts)) {
+    let kind = val.as_kind();
+    let kind = kind.map_ref_with_special_handling_of_binders(
+        |v| value_to_expr(ctx, v, opts),
+        |binder, v| value_to_expr(&ctx.insert(binder), v, opts),
+    );
+    match kind {
+        ValueKind::Var(v) => {
+            let b = v.binder();
+            let (idx, name) = if opts.alpha {
+                (ctx.lookup(&b), "_".into())
+            } else {
+                (ctx.lookup_by_name(&b), b.name().clone())
+            };
+            match idx {
+                Some(idx) => rc(ExprKind::Var(V(name, idx))),
+                None => panic!(
+                    "internal error: binder {:?} not found in environment",
+                    b
+                ),
+            }
+        }
         ValueKind::Lam(x, t, e) => {
             rc(ExprKind::Lam(x.to_label_maybe_alpha(opts.alpha), t, e))
         }
@@ -33,7 +54,6 @@ pub(crate) fn value_to_expr(
         ValueKind::Pi(x, t, e) => {
             rc(ExprKind::Pi(x.to_label_maybe_alpha(opts.alpha), t, e))
         }
-        ValueKind::Var(v) => rc(ExprKind::Var(v.to_var(opts.alpha))),
         ValueKind::Const(c) => rc(ExprKind::Const(c)),
         ValueKind::BoolLit(b) => rc(ExprKind::BoolLit(b)),
         ValueKind::NaturalLit(n) => rc(ExprKind::NaturalLit(n)),
-- 
cgit v1.2.3


From fc1d7b758008643447f17bc9d05adb128d1567cc Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 17 Jan 2020 10:25:28 +0000
Subject: Remove binder ids

The underlying purpose of them turned out to be unsound
---
 dhall/src/semantics/core/context.rs | 53 ++---------------------------
 dhall/src/semantics/core/value.rs   | 67 +++----------------------------------
 dhall/src/semantics/core/var.rs     | 32 +++++-------------
 dhall/src/semantics/to_expr.rs      | 23 ++-----------
 dhall/src/syntax/ast/expr.rs        |  9 +++++
 5 files changed, 28 insertions(+), 156 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index 826ba15..3a7930e 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -1,6 +1,4 @@
-use std::cell::RefCell;
 use std::collections::HashMap;
-use std::rc::Rc;
 
 use crate::error::TypeError;
 use crate::semantics::core::value::Value;
@@ -17,28 +15,14 @@ enum CtxItem {
 #[derive(Debug, Clone)]
 pub(crate) struct TyCtx {
     ctx: Vec<(Binder, CtxItem)>,
-    /// Keeps track of the next free binder id to assign. Shared among all the contexts to ensure
-    /// unicity across the expression.
-    next_uid: Rc<RefCell<u64>>,
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct VarCtx<'b> {
-    ctx: Vec<&'b Binder>,
 }
 
 impl TyCtx {
     pub fn new() -> Self {
-        TyCtx {
-            ctx: Vec::new(),
-            next_uid: Rc::new(RefCell::new(0)),
-        }
+        TyCtx { ctx: Vec::new() }
     }
     fn with_vec(&self, vec: Vec<(Binder, CtxItem)>) -> Self {
-        TyCtx {
-            ctx: vec,
-            next_uid: self.next_uid.clone(),
-        }
+        TyCtx { ctx: vec }
     }
     pub fn insert_type(&self, x: &Binder, t: Value) -> Self {
         let mut vec = self.ctx.clone();
@@ -79,10 +63,7 @@ impl TyCtx {
         None
     }
     pub fn new_binder(&self, l: &Label) -> Binder {
-        let mut next_uid = self.next_uid.borrow_mut();
-        let uid = *next_uid;
-        *next_uid += 1;
-        Binder::new(l.clone(), uid)
+        Binder::new(l.clone())
     }
 
     /// Given a var that makes sense in the current context, map the given function in such a way
@@ -133,34 +114,6 @@ impl TyCtx {
     }
 }
 
-impl<'b> VarCtx<'b> {
-    pub fn new() -> Self {
-        VarCtx { ctx: Vec::new() }
-    }
-    pub fn insert(&self, binder: &'b Binder) -> Self {
-        VarCtx {
-            ctx: self.ctx.iter().copied().chain(Some(binder)).collect(),
-        }
-    }
-    pub fn lookup(&self, binder: &Binder) -> Option<usize> {
-        self.ctx
-            .iter()
-            .rev()
-            .enumerate()
-            .find(|(_, other)| binder.same_binder(other))
-            .map(|(i, _)| i)
-    }
-    pub fn lookup_by_name(&self, binder: &Binder) -> Option<usize> {
-        self.ctx
-            .iter()
-            .rev()
-            .filter(|other| binder.name() == other.name())
-            .enumerate()
-            .find(|(_, other)| binder.same_binder(other))
-            .map(|(i, _)| i)
-    }
-}
-
 impl Shift for CtxItem {
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
         Some(match self {
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 26b8672..b4e4e61 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -1,10 +1,9 @@
-use std::borrow::Cow;
 use std::cell::{Ref, RefCell, RefMut};
 use std::collections::HashMap;
 use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
-use crate::semantics::core::context::{TyCtx, VarCtx};
+use crate::semantics::core::context::TyCtx;
 use crate::semantics::core::var::{AlphaVar, Binder, Shift, Subst};
 use crate::semantics::phase::normalize::{apply_any, normalize_whnf};
 use crate::semantics::phase::typecheck::{builtin_to_value, const_to_value};
@@ -164,7 +163,7 @@ impl Value {
         &self,
         opts: to_expr::ToExprOptions,
     ) -> NormalizedExpr {
-        to_expr::value_to_expr(&VarCtx::new(), self, opts)
+        to_expr::value_to_expr(self, opts)
     }
     pub(crate) fn to_whnf_ignore_type(&self) -> ValueKind<Value> {
         self.as_whnf().clone()
@@ -410,65 +409,6 @@ impl<V> ValueKind<V> {
     }
 }
 
-/// Compare two values for equality modulo alpha/beta-equivalence.
-// TODO: use Rc comparison to shortcut on identical pointers
-fn equiv(val1: &Value, val2: &Value) -> bool {
-    struct ValueWithCtx<'v, 'c> {
-        val: &'v Value,
-        ctx: Cow<'c, VarCtx<'v>>,
-    }
-    impl<'v, 'c> PartialEq for ValueWithCtx<'v, 'c> {
-        fn eq(&self, other: &ValueWithCtx<'v, 'c>) -> bool {
-            equiv_with_ctx(&*self.ctx, self.val, &*other.ctx, other.val)
-        }
-    }
-    // Push the given context into every subnode of the ValueKind. That way, normal equality of the
-    // resulting value will take into account the context.
-    fn push_context_through<'v, 'c>(
-        ctx: &'c VarCtx<'v>,
-        kind: &'v ValueKind<Value>,
-    ) -> ValueKind<ValueWithCtx<'v, 'c>> {
-        kind.map_ref_with_special_handling_of_binders(
-            |val| ValueWithCtx {
-                val,
-                ctx: Cow::Borrowed(ctx),
-            },
-            |binder, val| ValueWithCtx {
-                val,
-                ctx: Cow::Owned(ctx.insert(binder)),
-            },
-        )
-    }
-
-    fn equiv_with_ctx<'v, 'c>(
-        ctx1: &'c VarCtx<'v>,
-        val1: &'v Value,
-        ctx2: &'c VarCtx<'v>,
-        val2: &'v Value,
-    ) -> bool {
-        use ValueKind::Var;
-        let kind1 = val1.as_whnf();
-        let kind2 = val2.as_whnf();
-
-        if let (Var(v1), Var(v2)) = (&*kind1, &*kind2) {
-            let b1 = v1.binder();
-            let b2 = v2.binder();
-            if b1.same_binder(&b2) {
-                return true;
-            }
-            match (ctx1.lookup(&b1), ctx2.lookup(&b2)) {
-                (Some(i), Some(j)) => i == j,
-                _ => false,
-            }
-        } else {
-            push_context_through(ctx1, &*kind1)
-                == push_context_through(ctx2, &*kind2)
-        }
-    }
-
-    equiv_with_ctx(&VarCtx::new(), val1, &VarCtx::new(), val2)
-}
-
 impl Shift for Value {
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
         Some(Value(self.0.shift(delta, var)?))
@@ -646,9 +586,10 @@ impl Subst<Value> for ValueKind<Value> {
     }
 }
 
+// TODO: use Rc comparison to shortcut on identical pointers
 impl std::cmp::PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {
-        equiv(self, other)
+        *self.as_whnf() == *other.as_whnf()
     }
 }
 impl std::cmp::Eq for Value {}
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index d21fa80..99d3125 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -9,21 +9,13 @@ use crate::syntax::{ExprKind, InterpolatedTextContents, Label, V};
 pub struct AlphaVar {
     normal: V<Label>,
     alpha: V<()>,
-    /// Id of the corresponding binder.
-    binder_uid: BinderUID,
 }
 
-type BinderUID = u64;
-
 // Exactly like a Label, but equality returns always true.
 // This is so that ValueKind equality is exactly alpha-equivalence.
 #[derive(Clone, Eq)]
 pub struct Binder {
     name: Label,
-    /// Id of the binder, unique across the current expression. Used to distinguish bindersinstead
-    /// of their name. The id won't actually be unique when there are imports around, but
-    /// typechecking ensures this can't cause a conflict.
-    uid: BinderUID,
 }
 
 pub(crate) trait Shift: Sized {
@@ -65,20 +57,18 @@ pub(crate) trait Subst<S> {
 }
 
 impl AlphaVar {
-    pub(crate) fn binder(&self) -> Binder {
-        Binder::new(self.normal.0.clone(), self.binder_uid)
+    pub(crate) fn to_var_maybe_alpha(&self, alpha: bool) -> V<Label> {
+        if alpha {
+            V("_".into(), self.alpha.idx())
+        } else {
+            self.normal.clone()
+        }
     }
 }
 
 impl Binder {
-    pub(crate) fn new(name: Label, uid: BinderUID) -> Self {
-        Binder { name, uid }
-    }
-    pub(crate) fn name(&self) -> &Label {
-        &self.name
-    }
-    pub(crate) fn same_binder(&self, other: &Binder) -> bool {
-        self.uid == other.uid
+    pub(crate) fn new(name: Label) -> Self {
+        Binder { name }
     }
     pub(crate) fn to_label_maybe_alpha(&self, alpha: bool) -> Label {
         if alpha {
@@ -97,7 +87,6 @@ impl Shift for AlphaVar {
         Some(AlphaVar {
             normal: self.normal.shift(delta, &var.normal)?,
             alpha: self.alpha.shift(delta, &var.alpha)?,
-            binder_uid: self.binder_uid,
         })
     }
 }
@@ -108,6 +97,7 @@ impl std::cmp::PartialEq for AlphaVar {
         self.alpha == other.alpha
     }
 }
+/// Equality up to alpha-equivalence
 impl std::cmp::PartialEq for Binder {
     fn eq(&self, _other: &Self) -> bool {
         true
@@ -131,18 +121,14 @@ impl<'a> From<&'a Label> for AlphaVar {
         AlphaVar {
             normal: V(x.clone(), 0),
             alpha: V((), 0),
-            // TODO: evil evil but only used in shift
-            binder_uid: 0,
         }
     }
 }
 impl From<Binder> for AlphaVar {
     fn from(x: Binder) -> AlphaVar {
-        let binder_uid = x.uid;
         AlphaVar {
             normal: V(x.into(), 0),
             alpha: V((), 0),
-            binder_uid,
         }
     }
 }
diff --git a/dhall/src/semantics/to_expr.rs b/dhall/src/semantics/to_expr.rs
index 1ece1cc..1adfd49 100644
--- a/dhall/src/semantics/to_expr.rs
+++ b/dhall/src/semantics/to_expr.rs
@@ -1,9 +1,8 @@
-use crate::semantics::core::context::VarCtx;
 use crate::semantics::phase::typecheck::rc;
 use crate::semantics::phase::NormalizedExpr;
 use crate::semantics::{Value, ValueKind};
 use crate::syntax;
-use crate::syntax::{Builtin, ExprKind, V};
+use crate::syntax::{Builtin, ExprKind};
 
 /// Controls conversion from `Value` to `Expr`
 #[derive(Copy, Clone)]
@@ -16,7 +15,6 @@ pub(crate) struct ToExprOptions {
 
 /// Converts a value back to the corresponding AST expression.
 pub(crate) fn value_to_expr(
-    ctx: &VarCtx,
     val: &Value,
     opts: ToExprOptions,
 ) -> NormalizedExpr {
@@ -25,25 +23,10 @@ pub(crate) fn value_to_expr(
     }
 
     let kind = val.as_kind();
-    let kind = kind.map_ref_with_special_handling_of_binders(
-        |v| value_to_expr(ctx, v, opts),
-        |binder, v| value_to_expr(&ctx.insert(binder), v, opts),
-    );
+    let kind = kind.map_ref(|v| value_to_expr(v, opts));
     match kind {
         ValueKind::Var(v) => {
-            let b = v.binder();
-            let (idx, name) = if opts.alpha {
-                (ctx.lookup(&b), "_".into())
-            } else {
-                (ctx.lookup_by_name(&b), b.name().clone())
-            };
-            match idx {
-                Some(idx) => rc(ExprKind::Var(V(name, idx))),
-                None => panic!(
-                    "internal error: binder {:?} not found in environment",
-                    b
-                ),
-            }
+            rc(ExprKind::Var(v.to_var_maybe_alpha(opts.alpha)))
         }
         ValueKind::Lam(x, t, e) => {
             rc(ExprKind::Lam(x.to_label_maybe_alpha(opts.alpha), t, e))
diff --git a/dhall/src/syntax/ast/expr.rs b/dhall/src/syntax/ast/expr.rs
index 376480f..0ac31a5 100644
--- a/dhall/src/syntax/ast/expr.rs
+++ b/dhall/src/syntax/ast/expr.rs
@@ -173,6 +173,15 @@ pub enum ExprKind<SubExpr, Embed> {
     Embed(Embed),
 }
 
+impl<Label> V<Label> {
+    pub(crate) fn name(&self) -> &Label {
+        &self.0
+    }
+    pub(crate) fn idx(&self) -> usize {
+        self.1
+    }
+}
+
 impl<SE, E> ExprKind<SE, E> {
     pub fn traverse_ref_with_special_handling_of_binders<'a, SE2, Err>(
         &'a self,
-- 
cgit v1.2.3


From f7a8d967b02bc20c093d501746ed3de53cc7da13 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 17 Jan 2020 10:49:02 +0000
Subject: Simplify Shift and Subst instances

---
 dhall/src/semantics/core/value.rs | 165 +++++++++-----------------------------
 dhall/src/semantics/core/var.rs   | 144 +--------------------------------
 dhall/src/syntax/ast/expr.rs      |   3 -
 3 files changed, 39 insertions(+), 273 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index b4e4e61..28f8e37 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -381,21 +381,30 @@ impl ValueKind<Value> {
 }
 
 impl<V> ValueKind<V> {
+    pub(crate) fn traverse_ref_with_special_handling_of_binders<'a, V2, E>(
+        &'a self,
+        visit_val: impl FnMut(&'a V) -> Result<V2, E>,
+        visit_under_binder: impl FnMut(&'a Binder, &'a V) -> Result<V2, E>,
+    ) -> Result<ValueKind<V2>, E> {
+        use crate::semantics::visitor;
+        use visitor::ValueKindVisitor;
+        visitor::TraverseRefWithBindersVisitor {
+            visit_val,
+            visit_under_binder,
+        }
+        .visit(self)
+    }
+
     pub(crate) fn map_ref_with_special_handling_of_binders<'a, V2>(
         &'a self,
         mut map_val: impl FnMut(&'a V) -> V2,
         mut map_under_binder: impl FnMut(&'a Binder, &'a V) -> V2,
     ) -> ValueKind<V2> {
-        use crate::semantics::visitor;
         use crate::syntax::trivial_result;
-        use visitor::ValueKindVisitor;
-        trivial_result(
-            visitor::TraverseRefWithBindersVisitor {
-                visit_val: |x| Ok(map_val(x)),
-                visit_under_binder: |l, x| Ok(map_under_binder(l, x)),
-            }
-            .visit(self),
-        )
+        trivial_result(self.traverse_ref_with_special_handling_of_binders(
+            |x| Ok(map_val(x)),
+            |l, x| Ok(map_under_binder(l, x)),
+        ))
     }
 
     #[allow(dead_code)]
@@ -411,7 +420,9 @@ impl<V> ValueKind<V> {
 
 impl Shift for Value {
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(Value(self.0.shift(delta, var)?))
+        Some(Value(Rc::new(RefCell::new(
+            self.0.borrow().shift(delta, var)?,
+        ))))
     }
 }
 
@@ -420,7 +431,10 @@ impl Shift for ValueInternal {
         Some(ValueInternal {
             form: self.form,
             kind: self.kind.shift(delta, var)?,
-            ty: self.ty.shift(delta, var)?,
+            ty: match &self.ty {
+                None => None,
+                Some(ty) => Some(ty.shift(delta, var)?),
+            },
             span: self.span.clone(),
         })
     }
@@ -429,64 +443,11 @@ impl Shift for ValueInternal {
 impl Shift for ValueKind<Value> {
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
         Some(match self {
-            ValueKind::Lam(x, t, e) => ValueKind::Lam(
-                x.clone(),
-                t.shift(delta, var)?,
-                e.shift(delta, &var.under_binder(x))?,
-            ),
-            ValueKind::AppliedBuiltin(b, args) => {
-                ValueKind::AppliedBuiltin(*b, args.shift(delta, var)?)
-            }
-            ValueKind::Pi(x, t, e) => ValueKind::Pi(
-                x.clone(),
-                t.shift(delta, var)?,
-                e.shift(delta, &var.under_binder(x))?,
-            ),
             ValueKind::Var(v) => ValueKind::Var(v.shift(delta, var)?),
-            ValueKind::Const(c) => ValueKind::Const(*c),
-            ValueKind::BoolLit(b) => ValueKind::BoolLit(*b),
-            ValueKind::NaturalLit(n) => ValueKind::NaturalLit(*n),
-            ValueKind::IntegerLit(n) => ValueKind::IntegerLit(*n),
-            ValueKind::DoubleLit(n) => ValueKind::DoubleLit(*n),
-            ValueKind::EmptyOptionalLit(tth) => {
-                ValueKind::EmptyOptionalLit(tth.shift(delta, var)?)
-            }
-            ValueKind::NEOptionalLit(th) => {
-                ValueKind::NEOptionalLit(th.shift(delta, var)?)
-            }
-            ValueKind::EmptyListLit(tth) => {
-                ValueKind::EmptyListLit(tth.shift(delta, var)?)
-            }
-            ValueKind::NEListLit(elts) => {
-                ValueKind::NEListLit(elts.shift(delta, var)?)
-            }
-            ValueKind::RecordLit(kvs) => {
-                ValueKind::RecordLit(kvs.shift(delta, var)?)
-            }
-            ValueKind::RecordType(kvs) => {
-                ValueKind::RecordType(kvs.shift(delta, var)?)
-            }
-            ValueKind::UnionType(kts) => {
-                ValueKind::UnionType(kts.shift(delta, var)?)
-            }
-            ValueKind::UnionConstructor(x, kts) => {
-                ValueKind::UnionConstructor(x.clone(), kts.shift(delta, var)?)
-            }
-            ValueKind::UnionLit(x, v, kts) => ValueKind::UnionLit(
-                x.clone(),
-                v.shift(delta, var)?,
-                kts.shift(delta, var)?,
-            ),
-            ValueKind::TextLit(elts) => {
-                ValueKind::TextLit(elts.shift(delta, var)?)
-            }
-            ValueKind::Equivalence(x, y) => ValueKind::Equivalence(
-                x.shift(delta, var)?,
-                y.shift(delta, var)?,
-            ),
-            ValueKind::PartialExpr(e) => {
-                ValueKind::PartialExpr(e.shift(delta, var)?)
-            }
+            _ => self.traverse_ref_with_special_handling_of_binders(
+                |x| Ok(x.shift(delta, var)?),
+                |b, x| Ok(x.shift(delta, &var.under_binder(b))?),
+            )?,
         })
     }
 }
@@ -502,7 +463,9 @@ impl Subst<Value> for Value {
                 }
                 val.clone()
             }
-            _ => Value(self.0.subst_shift(var, val)),
+            _ => Value(Rc::new(RefCell::new(
+                self.0.borrow().subst_shift(var, val),
+            ))),
         }
     }
 }
@@ -513,7 +476,7 @@ impl Subst<Value> for ValueInternal {
             // The resulting value may not stay in wnhf after substitution
             form: Unevaled,
             kind: self.kind.subst_shift(var, val),
-            ty: self.ty.subst_shift(var, val),
+            ty: self.ty.as_ref().map(|x| x.subst_shift(var, val)),
             span: self.span.clone(),
         }
     }
@@ -522,65 +485,13 @@ impl Subst<Value> for ValueInternal {
 impl Subst<Value> for ValueKind<Value> {
     fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
         match self {
-            ValueKind::AppliedBuiltin(b, args) => {
-                ValueKind::AppliedBuiltin(*b, args.subst_shift(var, val))
-            }
-            ValueKind::PartialExpr(e) => {
-                ValueKind::PartialExpr(e.subst_shift(var, val))
-            }
-            ValueKind::TextLit(elts) => {
-                ValueKind::TextLit(elts.subst_shift(var, val))
-            }
-            ValueKind::Lam(x, t, e) => ValueKind::Lam(
-                x.clone(),
-                t.subst_shift(var, val),
-                e.subst_shift(&var.under_binder(x), &val.under_binder(x)),
-            ),
-            ValueKind::Pi(x, t, e) => ValueKind::Pi(
-                x.clone(),
-                t.subst_shift(var, val),
-                e.subst_shift(&var.under_binder(x), &val.under_binder(x)),
-            ),
             ValueKind::Var(v) if v == var => val.to_whnf_ignore_type(),
             ValueKind::Var(v) => ValueKind::Var(v.shift(-1, var).unwrap()),
-            ValueKind::Const(c) => ValueKind::Const(*c),
-            ValueKind::BoolLit(b) => ValueKind::BoolLit(*b),
-            ValueKind::NaturalLit(n) => ValueKind::NaturalLit(*n),
-            ValueKind::IntegerLit(n) => ValueKind::IntegerLit(*n),
-            ValueKind::DoubleLit(n) => ValueKind::DoubleLit(*n),
-            ValueKind::EmptyOptionalLit(tth) => {
-                ValueKind::EmptyOptionalLit(tth.subst_shift(var, val))
-            }
-            ValueKind::NEOptionalLit(th) => {
-                ValueKind::NEOptionalLit(th.subst_shift(var, val))
-            }
-            ValueKind::EmptyListLit(tth) => {
-                ValueKind::EmptyListLit(tth.subst_shift(var, val))
-            }
-            ValueKind::NEListLit(elts) => {
-                ValueKind::NEListLit(elts.subst_shift(var, val))
-            }
-            ValueKind::RecordLit(kvs) => {
-                ValueKind::RecordLit(kvs.subst_shift(var, val))
-            }
-            ValueKind::RecordType(kvs) => {
-                ValueKind::RecordType(kvs.subst_shift(var, val))
-            }
-            ValueKind::UnionType(kts) => {
-                ValueKind::UnionType(kts.subst_shift(var, val))
-            }
-            ValueKind::UnionConstructor(x, kts) => ValueKind::UnionConstructor(
-                x.clone(),
-                kts.subst_shift(var, val),
-            ),
-            ValueKind::UnionLit(x, v, kts) => ValueKind::UnionLit(
-                x.clone(),
-                v.subst_shift(var, val),
-                kts.subst_shift(var, val),
-            ),
-            ValueKind::Equivalence(x, y) => ValueKind::Equivalence(
-                x.subst_shift(var, val),
-                y.subst_shift(var, val),
+            _ => self.map_ref_with_special_handling_of_binders(
+                |x| x.subst_shift(var, val),
+                |b, x| {
+                    x.subst_shift(&var.under_binder(b), &val.under_binder(b))
+                },
             ),
         }
     }
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index 99d3125..c21e53e 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::syntax::{ExprKind, InterpolatedTextContents, Label, V};
+use crate::syntax::{Label, V};
 
 /// Stores a pair of variables: a normal one and one
 /// that corresponds to the alpha-normalized version of the first one.
@@ -143,145 +143,3 @@ impl From<Binder> for Label {
         x.name
     }
 }
-impl Shift for () {
-    fn shift(&self, _delta: isize, _var: &AlphaVar) -> Option<Self> {
-        Some(())
-    }
-}
-
-impl<A: Shift, B: Shift> Shift for (A, B) {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some((self.0.shift(delta, var)?, self.1.shift(delta, var)?))
-    }
-}
-
-impl<T: Shift> Shift for Option<T> {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(match self {
-            None => None,
-            Some(x) => Some(x.shift(delta, var)?),
-        })
-    }
-}
-
-impl<T: Shift> Shift for Box<T> {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(Box::new(self.as_ref().shift(delta, var)?))
-    }
-}
-
-impl<T: Shift> Shift for std::rc::Rc<T> {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(std::rc::Rc::new(self.as_ref().shift(delta, var)?))
-    }
-}
-
-impl<T: Shift> Shift for std::cell::RefCell<T> {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(std::cell::RefCell::new(self.borrow().shift(delta, var)?))
-    }
-}
-
-impl<T: Shift, E: Clone> Shift for ExprKind<T, E> {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(self.traverse_ref_with_special_handling_of_binders(
-            |v| Ok(v.shift(delta, var)?),
-            |x, v| Ok(v.shift(delta, &var.under_binder(x))?),
-        )?)
-    }
-}
-
-impl<T: Shift> Shift for Vec<T> {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(
-            self.iter()
-                .map(|v| Ok(v.shift(delta, var)?))
-                .collect::<Result<_, _>>()?,
-        )
-    }
-}
-
-impl<K, T: Shift> Shift for HashMap<K, T>
-where
-    K: Clone + std::hash::Hash + Eq,
-{
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(
-            self.iter()
-                .map(|(k, v)| Ok((k.clone(), v.shift(delta, var)?)))
-                .collect::<Result<_, _>>()?,
-        )
-    }
-}
-
-impl<T: Shift> Shift for InterpolatedTextContents<T> {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(self.traverse_ref(|x| Ok(x.shift(delta, var)?))?)
-    }
-}
-
-impl<S> Subst<S> for () {
-    fn subst_shift(&self, _var: &AlphaVar, _val: &S) -> Self {}
-}
-
-impl<S, A: Subst<S>, B: Subst<S>> Subst<S> for (A, B) {
-    fn subst_shift(&self, var: &AlphaVar, val: &S) -> Self {
-        (self.0.subst_shift(var, val), self.1.subst_shift(var, val))
-    }
-}
-
-impl<S, T: Subst<S>> Subst<S> for Option<T> {
-    fn subst_shift(&self, var: &AlphaVar, val: &S) -> Self {
-        self.as_ref().map(|x| x.subst_shift(var, val))
-    }
-}
-
-impl<S, T: Subst<S>> Subst<S> for Box<T> {
-    fn subst_shift(&self, var: &AlphaVar, val: &S) -> Self {
-        Box::new(self.as_ref().subst_shift(var, val))
-    }
-}
-
-impl<S, T: Subst<S>> Subst<S> for std::rc::Rc<T> {
-    fn subst_shift(&self, var: &AlphaVar, val: &S) -> Self {
-        std::rc::Rc::new(self.as_ref().subst_shift(var, val))
-    }
-}
-
-impl<S, T: Subst<S>> Subst<S> for std::cell::RefCell<T> {
-    fn subst_shift(&self, var: &AlphaVar, val: &S) -> Self {
-        std::cell::RefCell::new(self.borrow().subst_shift(var, val))
-    }
-}
-
-impl<S: Shift, T: Subst<S>, E: Clone> Subst<S> for ExprKind<T, E> {
-    fn subst_shift(&self, var: &AlphaVar, val: &S) -> Self {
-        self.map_ref_with_special_handling_of_binders(
-            |v| v.subst_shift(var, val),
-            |x, v| v.subst_shift(&var.under_binder(x), &val.under_binder(x)),
-        )
-    }
-}
-
-impl<S, T: Subst<S>> Subst<S> for Vec<T> {
-    fn subst_shift(&self, var: &AlphaVar, val: &S) -> Self {
-        self.iter().map(|v| v.subst_shift(var, val)).collect()
-    }
-}
-
-impl<S, T: Subst<S>> Subst<S> for InterpolatedTextContents<T> {
-    fn subst_shift(&self, var: &AlphaVar, val: &S) -> Self {
-        self.map_ref(|x| x.subst_shift(var, val))
-    }
-}
-
-impl<S, K, T: Subst<S>> Subst<S> for HashMap<K, T>
-where
-    K: Clone + std::hash::Hash + Eq,
-{
-    fn subst_shift(&self, var: &AlphaVar, val: &S) -> Self {
-        self.iter()
-            .map(|(k, v)| (k.clone(), v.subst_shift(var, val)))
-            .collect()
-    }
-}
diff --git a/dhall/src/syntax/ast/expr.rs b/dhall/src/syntax/ast/expr.rs
index 0ac31a5..04b5adc 100644
--- a/dhall/src/syntax/ast/expr.rs
+++ b/dhall/src/syntax/ast/expr.rs
@@ -174,9 +174,6 @@ pub enum ExprKind<SubExpr, Embed> {
 }
 
 impl<Label> V<Label> {
-    pub(crate) fn name(&self) -> &Label {
-        &self.0
-    }
     pub(crate) fn idx(&self) -> usize {
         self.1
     }
-- 
cgit v1.2.3


From 72d1e3c339cf550fa5af9981af6078a813feb80a Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 17 Jan 2020 11:03:40 +0000
Subject: Remove Shift/Subst traits

---
 dhall/src/semantics/core/context.rs    | 105 +++++-----------------
 dhall/src/semantics/core/value.rs      | 158 ++++++++++++++++-----------------
 dhall/src/semantics/core/var.rs        |  63 +++----------
 dhall/src/semantics/phase/mod.rs       |  13 ---
 dhall/src/semantics/phase/normalize.rs |   1 -
 dhall/src/semantics/phase/typecheck.rs |   2 +-
 6 files changed, 115 insertions(+), 227 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index 3a7930e..16ea48f 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use crate::error::TypeError;
 use crate::semantics::core::value::Value;
 use crate::semantics::core::value::ValueKind;
-use crate::semantics::core::var::{AlphaVar, Binder, Shift, Subst};
+use crate::semantics::core::var::{AlphaVar, Binder};
 use crate::syntax::{Label, V};
 
 #[derive(Debug, Clone)]
@@ -17,6 +17,27 @@ pub(crate) struct TyCtx {
     ctx: Vec<(Binder, CtxItem)>,
 }
 
+impl CtxItem {
+    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
+        Some(match self {
+            CtxItem::Kept(v, t) => {
+                CtxItem::Kept(v.shift(delta, var)?, t.shift(delta, var)?)
+            }
+            CtxItem::Replaced(e) => CtxItem::Replaced(e.shift(delta, var)?),
+        })
+    }
+    fn under_multiple_binders(&self, shift_map: &HashMap<Label, usize>) -> Self
+    where
+        Self: Clone,
+    {
+        let mut v = self.clone();
+        for (x, n) in shift_map {
+            v = v.shift(*n as isize, &x.into()).unwrap();
+        }
+        v
+    }
+}
+
 impl TyCtx {
     pub fn new() -> Self {
         TyCtx { ctx: Vec::new() }
@@ -65,86 +86,4 @@ impl TyCtx {
     pub fn new_binder(&self, l: &Label) -> Binder {
         Binder::new(l.clone())
     }
-
-    /// Given a var that makes sense in the current context, map the given function in such a way
-    /// that the passed variable always makes sense in the context of the passed item.
-    /// Once we pass the variable definition, the variable doesn't make sense anymore so we just
-    /// copy the remaining items.
-    fn do_with_var<E>(
-        &self,
-        var: &AlphaVar,
-        mut f: impl FnMut(&AlphaVar, &CtxItem) -> Result<CtxItem, E>,
-    ) -> Result<Self, E> {
-        let mut vec = Vec::new();
-        vec.reserve(self.ctx.len());
-        let mut var = var.clone();
-        let mut iter = self.ctx.iter().rev();
-        for (l, i) in iter.by_ref() {
-            vec.push((l.clone(), f(&var, i)?));
-            if let CtxItem::Kept(_, _) = i {
-                match var.over_binder(l) {
-                    None => break,
-                    Some(newvar) => var = newvar,
-                };
-            }
-        }
-        for (l, i) in iter {
-            vec.push((l.clone(), (*i).clone()));
-        }
-        vec.reverse();
-        Ok(self.with_vec(vec))
-    }
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        if delta < 0 {
-            Some(self.do_with_var(var, |var, i| Ok(i.shift(delta, &var)?))?)
-        } else {
-            Some(
-                self.with_vec(
-                    self.ctx
-                        .iter()
-                        .map(|(l, i)| Ok((l.clone(), i.shift(delta, &var)?)))
-                        .collect::<Result<_, _>>()?,
-                ),
-            )
-        }
-    }
-    fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
-        self.do_with_var(var, |var, i| Ok::<_, !>(i.subst_shift(&var, val)))
-            .unwrap()
-    }
-}
-
-impl Shift for CtxItem {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(match self {
-            CtxItem::Kept(v, t) => {
-                CtxItem::Kept(v.shift(delta, var)?, t.shift(delta, var)?)
-            }
-            CtxItem::Replaced(e) => CtxItem::Replaced(e.shift(delta, var)?),
-        })
-    }
-}
-
-impl Shift for TyCtx {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        self.shift(delta, var)
-    }
-}
-
-impl Subst<Value> for CtxItem {
-    fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
-        match self {
-            CtxItem::Replaced(e) => CtxItem::Replaced(e.subst_shift(var, val)),
-            CtxItem::Kept(v, t) => match v.shift(-1, var) {
-                None => CtxItem::Replaced(val.clone()),
-                Some(newvar) => CtxItem::Kept(newvar, t.subst_shift(var, val)),
-            },
-        }
-    }
-}
-
-impl Subst<Value> for TyCtx {
-    fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
-        self.subst_shift(var, val)
-    }
 }
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 28f8e37..ad03187 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -4,7 +4,7 @@ use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::context::TyCtx;
-use crate::semantics::core::var::{AlphaVar, Binder, Shift, Subst};
+use crate::semantics::core::var::{AlphaVar, Binder};
 use crate::semantics::phase::normalize::{apply_any, normalize_whnf};
 use crate::semantics::phase::typecheck::{builtin_to_value, const_to_value};
 use crate::semantics::phase::{Normalized, NormalizedExpr, Typed};
@@ -238,6 +238,40 @@ impl Value {
         self.get_type()
             .expect("Internal type error: value is `Sort` but shouldn't be")
     }
+
+    pub(crate) fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
+        Some(Value(Rc::new(RefCell::new(
+            self.0.borrow().shift(delta, var)?,
+        ))))
+    }
+    pub(crate) fn over_binder<T>(&self, x: T) -> Option<Self>
+    where
+        T: Into<AlphaVar>,
+    {
+        self.shift(-1, &x.into())
+    }
+    pub(crate) fn under_binder<T>(&self, x: T) -> Self
+    where
+        T: Into<AlphaVar>,
+    {
+        // Can't fail since delta is positive
+        self.shift(1, &x.into()).unwrap()
+    }
+    pub(crate) fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
+        match &*self.as_kind() {
+            // If the var matches, we can just reuse the provided value instead of copying it.
+            // We also check that the types match, if in debug mode.
+            ValueKind::Var(v) if v == var => {
+                if let Ok(self_ty) = self.get_type() {
+                    val.check_type(&self_ty.subst_shift(var, val));
+                }
+                val.clone()
+            }
+            _ => Value(Rc::new(RefCell::new(
+                self.0.borrow().subst_shift(var, val),
+            ))),
+        }
+    }
 }
 
 impl ValueInternal {
@@ -298,6 +332,27 @@ impl ValueInternal {
             None => Err(TypeError::new(&TyCtx::new(), TypeMessage::Sort)),
         }
     }
+
+    pub(crate) fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
+        Some(ValueInternal {
+            form: self.form,
+            kind: self.kind.shift(delta, var)?,
+            ty: match &self.ty {
+                None => None,
+                Some(ty) => Some(ty.shift(delta, var)?),
+            },
+            span: self.span.clone(),
+        })
+    }
+    pub(crate) fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
+        ValueInternal {
+            // The resulting value may not stay in wnhf after substitution
+            form: Unevaled,
+            kind: self.kind.subst_shift(var, val),
+            ty: self.ty.as_ref().map(|x| x.subst_shift(var, val)),
+            span: self.span.clone(),
+        }
+    }
 }
 
 impl ValueKind<Value> {
@@ -378,6 +433,28 @@ impl ValueKind<Value> {
     pub(crate) fn from_builtin(b: Builtin) -> ValueKind<Value> {
         ValueKind::AppliedBuiltin(b, vec![])
     }
+
+    pub(crate) fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
+        Some(match self {
+            ValueKind::Var(v) => ValueKind::Var(v.shift(delta, var)?),
+            _ => self.traverse_ref_with_special_handling_of_binders(
+                |x| Ok(x.shift(delta, var)?),
+                |b, x| Ok(x.shift(delta, &var.under_binder(b))?),
+            )?,
+        })
+    }
+    pub(crate) fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
+        match self {
+            ValueKind::Var(v) if v == var => val.to_whnf_ignore_type(),
+            ValueKind::Var(v) => ValueKind::Var(v.shift(-1, var).unwrap()),
+            _ => self.map_ref_with_special_handling_of_binders(
+                |x| x.subst_shift(var, val),
+                |b, x| {
+                    x.subst_shift(&var.under_binder(b), &val.under_binder(b))
+                },
+            ),
+        }
+    }
 }
 
 impl<V> ValueKind<V> {
@@ -418,85 +495,6 @@ impl<V> ValueKind<V> {
     }
 }
 
-impl Shift for Value {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(Value(Rc::new(RefCell::new(
-            self.0.borrow().shift(delta, var)?,
-        ))))
-    }
-}
-
-impl Shift for ValueInternal {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(ValueInternal {
-            form: self.form,
-            kind: self.kind.shift(delta, var)?,
-            ty: match &self.ty {
-                None => None,
-                Some(ty) => Some(ty.shift(delta, var)?),
-            },
-            span: self.span.clone(),
-        })
-    }
-}
-
-impl Shift for ValueKind<Value> {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(match self {
-            ValueKind::Var(v) => ValueKind::Var(v.shift(delta, var)?),
-            _ => self.traverse_ref_with_special_handling_of_binders(
-                |x| Ok(x.shift(delta, var)?),
-                |b, x| Ok(x.shift(delta, &var.under_binder(b))?),
-            )?,
-        })
-    }
-}
-
-impl Subst<Value> for Value {
-    fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
-        match &*self.as_kind() {
-            // If the var matches, we can just reuse the provided value instead of copying it.
-            // We also check that the types match, if in debug mode.
-            ValueKind::Var(v) if v == var => {
-                if let Ok(self_ty) = self.get_type() {
-                    val.check_type(&self_ty.subst_shift(var, val));
-                }
-                val.clone()
-            }
-            _ => Value(Rc::new(RefCell::new(
-                self.0.borrow().subst_shift(var, val),
-            ))),
-        }
-    }
-}
-
-impl Subst<Value> for ValueInternal {
-    fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
-        ValueInternal {
-            // The resulting value may not stay in wnhf after substitution
-            form: Unevaled,
-            kind: self.kind.subst_shift(var, val),
-            ty: self.ty.as_ref().map(|x| x.subst_shift(var, val)),
-            span: self.span.clone(),
-        }
-    }
-}
-
-impl Subst<Value> for ValueKind<Value> {
-    fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
-        match self {
-            ValueKind::Var(v) if v == var => val.to_whnf_ignore_type(),
-            ValueKind::Var(v) => ValueKind::Var(v.shift(-1, var).unwrap()),
-            _ => self.map_ref_with_special_handling_of_binders(
-                |x| x.subst_shift(var, val),
-                |b, x| {
-                    x.subst_shift(&var.under_binder(b), &val.under_binder(b))
-                },
-            ),
-        }
-    }
-}
-
 // TODO: use Rc comparison to shortcut on identical pointers
 impl std::cmp::PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index c21e53e..a110632 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-
 use crate::syntax::{Label, V};
 
 /// Stores a pair of variables: a normal one and one
@@ -18,44 +16,6 @@ pub struct Binder {
     name: Label,
 }
 
-pub(crate) trait Shift: Sized {
-    // Shift an expression to move it around binders without changing the meaning of its free
-    // variables. Shift by 1 to move an expression under a binder. Shift by -1 to extract an
-    // expression from under a binder, if the expression does not refer to that bound variable.
-    // Returns None if delta was negative and the variable was free in the expression.
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self>;
-
-    fn over_binder<T>(&self, x: T) -> Option<Self>
-    where
-        T: Into<AlphaVar>,
-    {
-        self.shift(-1, &x.into())
-    }
-
-    fn under_binder<T>(&self, x: T) -> Self
-    where
-        T: Into<AlphaVar>,
-    {
-        // Can't fail since delta is positive
-        self.shift(1, &x.into()).unwrap()
-    }
-
-    fn under_multiple_binders(&self, shift_map: &HashMap<Label, usize>) -> Self
-    where
-        Self: Clone,
-    {
-        let mut v = self.clone();
-        for (x, n) in shift_map {
-            v = v.shift(*n as isize, &x.into()).unwrap();
-        }
-        v
-    }
-}
-
-pub(crate) trait Subst<S> {
-    fn subst_shift(&self, var: &AlphaVar, val: &S) -> Self;
-}
-
 impl AlphaVar {
     pub(crate) fn to_var_maybe_alpha(&self, alpha: bool) -> V<Label> {
         if alpha {
@@ -64,6 +24,20 @@ impl AlphaVar {
             self.normal.clone()
         }
     }
+
+    pub(crate) fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
+        Some(AlphaVar {
+            normal: self.normal.shift(delta, &var.normal)?,
+            alpha: self.alpha.shift(delta, &var.alpha)?,
+        })
+    }
+    pub(crate) fn under_binder<T>(&self, x: T) -> Self
+    where
+        T: Into<AlphaVar>,
+    {
+        // Can't fail since delta is positive
+        self.shift(1, &x.into()).unwrap()
+    }
 }
 
 impl Binder {
@@ -82,15 +56,6 @@ impl Binder {
     }
 }
 
-impl Shift for AlphaVar {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(AlphaVar {
-            normal: self.normal.shift(delta, &var.normal)?,
-            alpha: self.alpha.shift(delta, &var.alpha)?,
-        })
-    }
-}
-
 /// Equality up to alpha-equivalence
 impl std::cmp::PartialEq for AlphaVar {
     fn eq(&self, other: &Self) -> bool {
diff --git a/dhall/src/semantics/phase/mod.rs b/dhall/src/semantics/phase/mod.rs
index 5d17338..6afed88 100644
--- a/dhall/src/semantics/phase/mod.rs
+++ b/dhall/src/semantics/phase/mod.rs
@@ -4,7 +4,6 @@ use std::path::Path;
 use crate::error::{EncodeError, Error, ImportError, TypeError};
 use crate::semantics::core::value::Value;
 use crate::semantics::core::value::ValueKind;
-use crate::semantics::core::var::{AlphaVar, Shift};
 use crate::semantics::to_expr::ToExprOptions;
 use crate::syntax::binary;
 use crate::syntax::{Builtin, Const, Expr};
@@ -191,18 +190,6 @@ impl Normalized {
     }
 }
 
-impl Shift for Typed {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(Typed(self.0.shift(delta, var)?))
-    }
-}
-
-impl Shift for Normalized {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(Normalized(self.0.shift(delta, var)?))
-    }
-}
-
 macro_rules! derive_traits_for_wrapper_struct {
     ($ty:ident) => {
         impl std::cmp::PartialEq for $ty {
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index 7b4b37f..615b2ff 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -3,7 +3,6 @@ use std::convert::TryInto;
 
 use crate::semantics::core::value::Value;
 use crate::semantics::core::value::ValueKind;
-use crate::semantics::core::var::Subst;
 use crate::semantics::phase::typecheck::{rc, typecheck};
 use crate::semantics::phase::Normalized;
 use crate::syntax;
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index 7e408eb..c77d9c4 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -6,7 +6,7 @@ use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::context::TyCtx;
 use crate::semantics::phase::normalize::merge_maps;
 use crate::semantics::phase::Normalized;
-use crate::semantics::{Binder, Shift, Subst, Value, ValueKind};
+use crate::semantics::{Binder, Value, ValueKind};
 use crate::syntax;
 use crate::syntax::{
     Builtin, Const, Expr, ExprKind, InterpolatedTextContents, Label, Span,
-- 
cgit v1.2.3


From 06f619e8b1654e506840d17dc1cbff4f2d9795c3 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 17 Jan 2020 11:26:34 +0000
Subject: Simplify a bit

---
 dhall/src/semantics/core/context.rs | 33 ++++++++-------------------------
 dhall/src/semantics/core/value.rs   | 26 ++++++++++++++++++--------
 dhall/src/semantics/core/var.rs     | 16 ++++++++++++++++
 3 files changed, 42 insertions(+), 33 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index 16ea48f..a6ab79e 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -17,27 +17,6 @@ pub(crate) struct TyCtx {
     ctx: Vec<(Binder, CtxItem)>,
 }
 
-impl CtxItem {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(match self {
-            CtxItem::Kept(v, t) => {
-                CtxItem::Kept(v.shift(delta, var)?, t.shift(delta, var)?)
-            }
-            CtxItem::Replaced(e) => CtxItem::Replaced(e.shift(delta, var)?),
-        })
-    }
-    fn under_multiple_binders(&self, shift_map: &HashMap<Label, usize>) -> Self
-    where
-        Self: Clone,
-    {
-        let mut v = self.clone();
-        for (x, n) in shift_map {
-            v = v.shift(*n as isize, &x.into()).unwrap();
-        }
-        v
-    }
-}
-
 impl TyCtx {
     pub fn new() -> Self {
         TyCtx { ctx: Vec::new() }
@@ -66,12 +45,16 @@ impl TyCtx {
             let l = b.to_label();
             match var.over_binder(&l) {
                 None => {
-                    let i = i.under_multiple_binders(&shift_map);
                     return Some(match i {
-                        CtxItem::Kept(newvar, t) => {
-                            Value::from_kind_and_type(ValueKind::Var(newvar), t)
+                        CtxItem::Kept(newvar, t) => Value::from_kind_and_type(
+                            ValueKind::Var(
+                                newvar.under_multiple_binders(&shift_map),
+                            ),
+                            t.under_multiple_binders(&shift_map),
+                        ),
+                        CtxItem::Replaced(v) => {
+                            v.under_multiple_binders(&shift_map)
                         }
-                        CtxItem::Replaced(v) => v,
                     });
                 }
                 Some(newvar) => var = newvar,
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index ad03187..049c2a9 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -240,9 +240,7 @@ impl Value {
     }
 
     pub(crate) fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(Value(Rc::new(RefCell::new(
-            self.0.borrow().shift(delta, var)?,
-        ))))
+        Some(self.0.borrow().shift(delta, var)?.into_value())
     }
     pub(crate) fn over_binder<T>(&self, x: T) -> Option<Self>
     where
@@ -257,6 +255,20 @@ impl Value {
         // Can't fail since delta is positive
         self.shift(1, &x.into()).unwrap()
     }
+    pub(crate) fn under_multiple_binders(
+        &self,
+        shift_map: &HashMap<Label, usize>,
+    ) -> Self
+    where
+        Self: Clone,
+    {
+        let mut v = self.clone();
+        for (x, n) in shift_map {
+            // Can't fail since delta is positive
+            v = v.shift(*n as isize, &x.into()).unwrap();
+        }
+        v
+    }
     pub(crate) fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
         match &*self.as_kind() {
             // If the var matches, we can just reuse the provided value instead of copying it.
@@ -267,9 +279,7 @@ impl Value {
                 }
                 val.clone()
             }
-            _ => Value(Rc::new(RefCell::new(
-                self.0.borrow().subst_shift(var, val),
-            ))),
+            _ => self.0.borrow().subst_shift(var, val).into_value(),
         }
     }
 }
@@ -434,7 +444,7 @@ impl ValueKind<Value> {
         ValueKind::AppliedBuiltin(b, vec![])
     }
 
-    pub(crate) fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
+    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
         Some(match self {
             ValueKind::Var(v) => ValueKind::Var(v.shift(delta, var)?),
             _ => self.traverse_ref_with_special_handling_of_binders(
@@ -443,7 +453,7 @@ impl ValueKind<Value> {
             )?,
         })
     }
-    pub(crate) fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
+    fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
         match self {
             ValueKind::Var(v) if v == var => val.to_whnf_ignore_type(),
             ValueKind::Var(v) => ValueKind::Var(v.shift(-1, var).unwrap()),
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index a110632..7c2c4de 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use crate::syntax::{Label, V};
 
 /// Stores a pair of variables: a normal one and one
@@ -38,6 +40,20 @@ impl AlphaVar {
         // Can't fail since delta is positive
         self.shift(1, &x.into()).unwrap()
     }
+    pub(crate) fn under_multiple_binders(
+        &self,
+        shift_map: &HashMap<Label, usize>,
+    ) -> Self
+    where
+        Self: Clone,
+    {
+        let mut v = self.clone();
+        for (x, n) in shift_map {
+            // Can't fail since delta is positive
+            v = v.shift(*n as isize, &x.into()).unwrap();
+        }
+        v
+    }
 }
 
 impl Binder {
-- 
cgit v1.2.3


From 37acac4b972b38e8dbe2d174dae1031e5a8eda67 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 17 Jan 2020 16:09:35 +0000
Subject: Tweak: handle empty lists in typeck

---
 dhall/src/semantics/phase/normalize.rs | 20 ++++----------------
 dhall/src/semantics/phase/typecheck.rs | 14 ++++++++++----
 2 files changed, 14 insertions(+), 20 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index 615b2ff..8f9a58a 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -590,9 +590,9 @@ pub(crate) fn normalize_one_layer(
     ty: &Value,
 ) -> ValueKind<Value> {
     use ValueKind::{
-        AppliedBuiltin, BoolLit, DoubleLit, EmptyListLit, EmptyOptionalLit,
-        IntegerLit, NEListLit, NEOptionalLit, NaturalLit, RecordLit, TextLit,
-        UnionConstructor, UnionLit, UnionType,
+        BoolLit, DoubleLit, EmptyOptionalLit, IntegerLit, NEListLit,
+        NEOptionalLit, NaturalLit, RecordLit, TextLit, UnionConstructor,
+        UnionLit, UnionType,
     };
 
     let ret = match expr {
@@ -609,6 +609,7 @@ pub(crate) fn normalize_one_layer(
         | ExprKind::Builtin(_)
         | ExprKind::Var(_)
         | ExprKind::Annot(_, _)
+        | ExprKind::EmptyListLit(_)
         | ExprKind::RecordType(_)
         | ExprKind::UnionType(_) => {
             unreachable!("This case should have been handled in typecheck")
@@ -620,19 +621,6 @@ pub(crate) fn normalize_one_layer(
         ExprKind::IntegerLit(n) => Ret::ValueKind(IntegerLit(n)),
         ExprKind::DoubleLit(n) => Ret::ValueKind(DoubleLit(n)),
         ExprKind::SomeLit(e) => Ret::ValueKind(NEOptionalLit(e)),
-        ExprKind::EmptyListLit(ref t) => {
-            // Check if the type is of the form `List x`
-            let t_borrow = t.as_whnf();
-            match &*t_borrow {
-                AppliedBuiltin(Builtin::List, args) if args.len() == 1 => {
-                    Ret::ValueKind(EmptyListLit(args[0].clone()))
-                }
-                _ => {
-                    drop(t_borrow);
-                    Ret::Expr(expr)
-                }
-            }
-        }
         ExprKind::NEListLit(elts) => {
             Ret::ValueKind(NEListLit(elts.into_iter().collect()))
         }
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index c77d9c4..852f41b 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -433,12 +433,18 @@ fn type_last_layer(
             RetTypeOnly(y.get_type()?)
         }
         EmptyListLit(t) => {
-            match &*t.as_whnf() {
+            let arg = match &*t.as_whnf() {
                 ValueKind::AppliedBuiltin(syntax::Builtin::List, args)
-                    if args.len() == 1 => {}
+                    if args.len() == 1 =>
+                {
+                    args[0].clone()
+                }
                 _ => return mkerr(InvalidListType(t.clone())),
-            }
-            RetTypeOnly(t.clone())
+            };
+            RetWhole(Value::from_kind_and_type(
+                ValueKind::EmptyListLit(arg),
+                t.clone(),
+            ))
         }
         NEListLit(xs) => {
             let mut iter = xs.iter().enumerate();
-- 
cgit v1.2.3


From 3881d36335fca6d72b0dd447130d6c1ce7ccbfee Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 17 Jan 2020 18:19:33 +0000
Subject: Implement bulk shifting

---
 dhall/src/semantics/core/context.rs | 57 ++++++++++++---------
 dhall/src/semantics/core/value.rs   | 98 +++++++++++++++++++++++++++++--------
 dhall/src/semantics/core/var.rs     | 16 +++---
 dhall/src/semantics/core/visitor.rs | 26 ++++++----
 dhall/src/syntax/ast/expr.rs        | 33 +++++++++++--
 5 files changed, 163 insertions(+), 67 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index a6ab79e..f8d6ff0 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -40,32 +40,43 @@ impl TyCtx {
     }
     pub fn lookup(&self, var: &V<Label>) -> Option<Value> {
         let mut var = var.clone();
-        let mut shift_map: HashMap<Label, _> = HashMap::new();
-        for (b, i) in self.ctx.iter().rev() {
-            let l = b.to_label();
-            match var.over_binder(&l) {
-                None => {
-                    return Some(match i {
-                        CtxItem::Kept(newvar, t) => Value::from_kind_and_type(
-                            ValueKind::Var(
-                                newvar.under_multiple_binders(&shift_map),
-                            ),
-                            t.under_multiple_binders(&shift_map),
-                        ),
-                        CtxItem::Replaced(v) => {
-                            v.under_multiple_binders(&shift_map)
-                        }
-                    });
+        let mut shift_map: HashMap<Label, usize> = HashMap::new();
+        let mut rev_ctx = self.ctx.iter().rev().map(|(b, i)| (b.to_label(), i));
+
+        let found_item = loop {
+            if let Some((label, item)) = rev_ctx.next() {
+                var = match var.over_binder(&label) {
+                    Some(newvar) => newvar,
+                    None => break item,
+                };
+                if let CtxItem::Kept(_, _) = item {
+                    *shift_map.entry(label).or_insert(0) += 1;
                 }
-                Some(newvar) => var = newvar,
-            };
-            if let CtxItem::Kept(_, _) = i {
-                *shift_map.entry(l).or_insert(0) += 1;
+            } else {
+                // Unbound variable
+                return None;
             }
-        }
-        // Unbound variable
-        None
+        };
+
+        let v = match found_item {
+            CtxItem::Kept(newvar, t) => Value::from_kind_and_type(
+                ValueKind::Var(newvar.clone()),
+                t.clone(),
+            ),
+            CtxItem::Replaced(v) => v.clone(),
+        };
+
+        let v = v.under_multiple_binders(&shift_map);
+        // for (x, n) in shift_map {
+        //     let x: AlphaVar = (&x).into();
+        //     // Can't fail since delta is positive
+        //     v = v.shift(n as isize, &x).unwrap();
+        // }
+        return Some(v);
     }
+    // pub fn lookup_alpha(&self, var: &AlphaVar) -> Option<Value> {
+    //     self.lookup(&var.normal)
+    // }
     pub fn new_binder(&self, l: &Label) -> Binder {
         Binder::new(l.clone())
     }
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 049c2a9..5aa337d 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -240,7 +240,7 @@ impl Value {
     }
 
     pub(crate) fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(self.0.borrow().shift(delta, var)?.into_value())
+        Some(self.as_internal().shift(delta, var)?.into_value())
     }
     pub(crate) fn over_binder<T>(&self, x: T) -> Option<Self>
     where
@@ -258,16 +258,10 @@ impl Value {
     pub(crate) fn under_multiple_binders(
         &self,
         shift_map: &HashMap<Label, usize>,
-    ) -> Self
-    where
-        Self: Clone,
-    {
-        let mut v = self.clone();
-        for (x, n) in shift_map {
-            // Can't fail since delta is positive
-            v = v.shift(*n as isize, &x.into()).unwrap();
-        }
-        v
+    ) -> Self {
+        self.as_internal()
+            .under_multiple_binders(shift_map)
+            .into_value()
     }
     pub(crate) fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
         match &*self.as_kind() {
@@ -279,9 +273,30 @@ impl Value {
                 }
                 val.clone()
             }
-            _ => self.0.borrow().subst_shift(var, val).into_value(),
+            _ => self.as_internal().subst_shift(var, val).into_value(),
         }
     }
+    // pub(crate) fn subst_ctx(&self, ctx: &TyCtx) -> Self {
+    //     match &*self.as_kind() {
+    //         ValueKind::Var(var) => match ctx.lookup_alpha(var) {
+    //             Some(val) => val,
+    //             None => unreachable!("Internal type error"),
+    //         },
+    //         kind => {
+    //             let kind = kind.map_ref_with_special_handling_of_binders(
+    //                 |x| x.subst_ctx(ctx),
+    //                 |b, t, x| x.subst_ctx(&ctx.insert_type(b, t.clone())),
+    //             );
+    //             ValueInternal {
+    //                 form: Unevaled,
+    //                 kind,
+    //                 ty: self.as_internal().ty.clone(),
+    //                 span: self.as_internal().span.clone(),
+    //             }
+    //             .into_value()
+    //         }
+    //     }
+    // }
 }
 
 impl ValueInternal {
@@ -343,7 +358,7 @@ impl ValueInternal {
         }
     }
 
-    pub(crate) fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
+    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
         Some(ValueInternal {
             form: self.form,
             kind: self.kind.shift(delta, var)?,
@@ -354,7 +369,21 @@ impl ValueInternal {
             span: self.span.clone(),
         })
     }
-    pub(crate) fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
+    fn under_multiple_binders(
+        &self,
+        shift_map: &HashMap<Label, usize>,
+    ) -> Self {
+        ValueInternal {
+            form: self.form,
+            kind: self.kind.under_multiple_binders(shift_map),
+            ty: match &self.ty {
+                None => None,
+                Some(ty) => Some(ty.under_multiple_binders(shift_map)),
+            },
+            span: self.span.clone(),
+        }
+    }
+    fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
         ValueInternal {
             // The resulting value may not stay in wnhf after substitution
             form: Unevaled,
@@ -449,17 +478,40 @@ impl ValueKind<Value> {
             ValueKind::Var(v) => ValueKind::Var(v.shift(delta, var)?),
             _ => self.traverse_ref_with_special_handling_of_binders(
                 |x| Ok(x.shift(delta, var)?),
-                |b, x| Ok(x.shift(delta, &var.under_binder(b))?),
+                |b, _, x| Ok(x.shift(delta, &var.under_binder(b))?),
             )?,
         })
     }
+    #[allow(dead_code)]
+    fn under_multiple_binders(
+        &self,
+        shift_map: &HashMap<Label, usize>,
+    ) -> Self {
+        match self {
+            ValueKind::Var(v) => {
+                ValueKind::Var(v.under_multiple_binders(shift_map))
+            }
+            _ => self.map_ref_with_special_handling_of_binders(
+                |v| v.under_multiple_binders(shift_map),
+                |b, _, v| {
+                    let mut v = v.clone();
+                    for (x, n) in shift_map {
+                        let x: AlphaVar = x.into();
+                        // Can't fail since delta is positive
+                        v = v.shift(*n as isize, &x.under_binder(b)).unwrap();
+                    }
+                    v
+                },
+            ),
+        }
+    }
     fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
         match self {
             ValueKind::Var(v) if v == var => val.to_whnf_ignore_type(),
-            ValueKind::Var(v) => ValueKind::Var(v.shift(-1, var).unwrap()),
+            ValueKind::Var(v) => ValueKind::Var(v.over_binder(var).unwrap()),
             _ => self.map_ref_with_special_handling_of_binders(
                 |x| x.subst_shift(var, val),
-                |b, x| {
+                |b, _, x| {
                     x.subst_shift(&var.under_binder(b), &val.under_binder(b))
                 },
             ),
@@ -471,7 +523,11 @@ impl<V> ValueKind<V> {
     pub(crate) fn traverse_ref_with_special_handling_of_binders<'a, V2, E>(
         &'a self,
         visit_val: impl FnMut(&'a V) -> Result<V2, E>,
-        visit_under_binder: impl FnMut(&'a Binder, &'a V) -> Result<V2, E>,
+        visit_under_binder: impl for<'b> FnMut(
+            &'a Binder,
+            &'b V,
+            &'a V,
+        ) -> Result<V2, E>,
     ) -> Result<ValueKind<V2>, E> {
         use crate::semantics::visitor;
         use visitor::ValueKindVisitor;
@@ -485,12 +541,12 @@ impl<V> ValueKind<V> {
     pub(crate) fn map_ref_with_special_handling_of_binders<'a, V2>(
         &'a self,
         mut map_val: impl FnMut(&'a V) -> V2,
-        mut map_under_binder: impl FnMut(&'a Binder, &'a V) -> V2,
+        mut map_under_binder: impl for<'b> FnMut(&'a Binder, &'b V, &'a V) -> V2,
     ) -> ValueKind<V2> {
         use crate::syntax::trivial_result;
         trivial_result(self.traverse_ref_with_special_handling_of_binders(
             |x| Ok(map_val(x)),
-            |l, x| Ok(map_under_binder(l, x)),
+            |l, t, x| Ok(map_under_binder(l, t, x)),
         ))
     }
 
@@ -499,7 +555,7 @@ impl<V> ValueKind<V> {
         &'a self,
         map_val: impl Fn(&'a V) -> V2,
     ) -> ValueKind<V2> {
-        self.map_ref_with_special_handling_of_binders(&map_val, |_, x| {
+        self.map_ref_with_special_handling_of_binders(&map_val, |_, _, x| {
             map_val(x)
         })
     }
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index 7c2c4de..d7666e3 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -40,19 +40,17 @@ impl AlphaVar {
         // Can't fail since delta is positive
         self.shift(1, &x.into()).unwrap()
     }
+    pub(crate) fn over_binder(&self, x: &AlphaVar) -> Option<Self> {
+        self.shift(-1, x)
+    }
     pub(crate) fn under_multiple_binders(
         &self,
         shift_map: &HashMap<Label, usize>,
-    ) -> Self
-    where
-        Self: Clone,
-    {
-        let mut v = self.clone();
-        for (x, n) in shift_map {
-            // Can't fail since delta is positive
-            v = v.shift(*n as isize, &x.into()).unwrap();
+    ) -> Self {
+        AlphaVar {
+            normal: self.normal.under_multiple_binders(shift_map),
+            alpha: self.alpha.under_multiple_binders(shift_map),
         }
-        v
     }
 }
 
diff --git a/dhall/src/semantics/core/visitor.rs b/dhall/src/semantics/core/visitor.rs
index 2c9ba92..e61a649 100644
--- a/dhall/src/semantics/core/visitor.rs
+++ b/dhall/src/semantics/core/visitor.rs
@@ -10,12 +10,13 @@ pub(crate) trait ValueKindVisitor<'a, V1, V2>: Sized {
     type Error;
 
     fn visit_val(&mut self, val: &'a V1) -> Result<V2, Self::Error>;
-    fn visit_val_under_binder(
+    fn visit_binder(
         mut self,
         _label: &'a Binder,
+        ty: &'a V1,
         val: &'a V1,
-    ) -> Result<V2, Self::Error> {
-        self.visit_val(val)
+    ) -> Result<(V2, V2), Self::Error> {
+        Ok((self.visit_val(ty)?, self.visit_val(val)?))
     }
     fn visit_vec(&mut self, x: &'a [V1]) -> Result<Vec<V2>, Self::Error> {
         x.iter().map(|e| self.visit_val(e)).collect()
@@ -72,10 +73,12 @@ where
     use ValueKind::*;
     Ok(match input {
         Lam(l, t, e) => {
-            Lam(l.clone(), v.visit_val(t)?, v.visit_val_under_binder(l, e)?)
+            let (t, e) = v.visit_binder(l, t, e)?;
+            Lam(l.clone(), t, e)
         }
         Pi(l, t, e) => {
-            Pi(l.clone(), v.visit_val(t)?, v.visit_val_under_binder(l, e)?)
+            let (t, e) = v.visit_binder(l, t, e)?;
+            Pi(l.clone(), t, e)
         }
         AppliedBuiltin(b, xs) => AppliedBuiltin(*b, v.visit_vec(xs)?),
         Var(v) => Var(v.clone()),
@@ -117,18 +120,21 @@ impl<'a, V1, V2, Err, F1, F2> ValueKindVisitor<'a, V1, V2>
 where
     V1: 'a,
     F1: FnMut(&'a V1) -> Result<V2, Err>,
-    F2: FnOnce(&'a Binder, &'a V1) -> Result<V2, Err>,
+    F2: for<'b> FnOnce(&'a Binder, &'b V1, &'a V1) -> Result<V2, Err>,
 {
     type Error = Err;
 
     fn visit_val(&mut self, val: &'a V1) -> Result<V2, Self::Error> {
         (self.visit_val)(val)
     }
-    fn visit_val_under_binder(
-        self,
+    fn visit_binder<'b>(
+        mut self,
         label: &'a Binder,
+        ty: &'a V1,
         val: &'a V1,
-    ) -> Result<V2, Self::Error> {
-        (self.visit_under_binder)(label, val)
+    ) -> Result<(V2, V2), Self::Error> {
+        let val = (self.visit_under_binder)(label, ty, val)?;
+        let ty = (self.visit_val)(ty)?;
+        Ok((ty, val))
     }
 }
diff --git a/dhall/src/syntax/ast/expr.rs b/dhall/src/syntax/ast/expr.rs
index 04b5adc..2372b0a 100644
--- a/dhall/src/syntax/ast/expr.rs
+++ b/dhall/src/syntax/ast/expr.rs
@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use crate::syntax::map::{DupTreeMap, DupTreeSet};
 use crate::syntax::visitor::{self, ExprKindMutVisitor, ExprKindVisitor};
 use crate::syntax::*;
@@ -302,7 +304,7 @@ impl<E> Expr<E> {
 }
 
 impl<Label: PartialEq + Clone> V<Label> {
-    pub fn shift(&self, delta: isize, var: &V<Label>) -> Option<Self> {
+    pub(crate) fn shift(&self, delta: isize, var: &V<Label>) -> Option<Self> {
         let V(x, n) = var;
         let V(y, m) = self;
         Some(if x == y && n <= m {
@@ -312,11 +314,35 @@ impl<Label: PartialEq + Clone> V<Label> {
         })
     }
 
-    pub fn over_binder(&self, x: &Label) -> Option<Self> {
+    pub(crate) fn over_binder(&self, x: &Label) -> Option<Self> {
         self.shift(-1, &V(x.clone(), 0))
     }
 }
 
+impl V<Label> {
+    pub(crate) fn under_multiple_binders(
+        &self,
+        shift_map: &HashMap<Label, usize>,
+    ) -> Self {
+        let name = &self.0;
+        let idx = self.1 + shift_map.get(name).unwrap_or(&0);
+        V(name.clone(), idx)
+    }
+}
+
+impl V<()> {
+    pub(crate) fn under_multiple_binders(
+        &self,
+        shift_map: &HashMap<Label, usize>,
+    ) -> Self {
+        let mut idx = self.1;
+        for (_, n) in shift_map {
+            idx += n;
+        }
+        V((), idx)
+    }
+}
+
 pub fn trivial_result<T>(x: Result<T, !>) -> T {
     match x {
         Ok(x) => x,
@@ -363,8 +389,7 @@ impl From<NaiveDouble> for f64 {
     }
 }
 
-/// This is only for the specific `Label` type, not generic
-impl From<Label> for V<Label> {
+impl<Label> From<Label> for V<Label> {
     fn from(x: Label) -> V<Label> {
         V(x, 0)
     }
-- 
cgit v1.2.3


From ab672506fd45e33f60b1b962c4757f912b6e27be Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 17 Jan 2020 18:31:45 +0000
Subject: Use alpha variables everywhere

Don't bother keeping name around, it complicates matters
---
 dhall/src/semantics/core/value.rs |  2 +-
 dhall/src/semantics/core/var.rs   | 30 +++++++++---------------------
 dhall/src/semantics/to_expr.rs    | 29 ++++++++++++++++++++++++-----
 3 files changed, 34 insertions(+), 27 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 5aa337d..d843a1b 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -163,7 +163,7 @@ impl Value {
         &self,
         opts: to_expr::ToExprOptions,
     ) -> NormalizedExpr {
-        to_expr::value_to_expr(self, opts)
+        to_expr::value_to_expr(self, opts, &vec![])
     }
     pub(crate) fn to_whnf_ignore_type(&self) -> ValueKind<Value> {
         self.as_whnf().clone()
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index d7666e3..f3475e7 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -2,12 +2,9 @@ use std::collections::HashMap;
 
 use crate::syntax::{Label, V};
 
-/// Stores a pair of variables: a normal one and one
-/// that corresponds to the alpha-normalized version of the first one.
-/// Equality is up to alpha-equivalence (compares on the second one only).
+/// Stores an alpha-normalized variable.
 #[derive(Clone, Eq)]
 pub struct AlphaVar {
-    normal: V<Label>,
     alpha: V<()>,
 }
 
@@ -19,17 +16,12 @@ pub struct Binder {
 }
 
 impl AlphaVar {
-    pub(crate) fn to_var_maybe_alpha(&self, alpha: bool) -> V<Label> {
-        if alpha {
-            V("_".into(), self.alpha.idx())
-        } else {
-            self.normal.clone()
-        }
+    pub(crate) fn idx(&self) -> usize {
+        self.alpha.idx()
     }
 
     pub(crate) fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
         Some(AlphaVar {
-            normal: self.normal.shift(delta, &var.normal)?,
             alpha: self.alpha.shift(delta, &var.alpha)?,
         })
     }
@@ -48,7 +40,6 @@ impl AlphaVar {
         shift_map: &HashMap<Label, usize>,
     ) -> Self {
         AlphaVar {
-            normal: self.normal.under_multiple_binders(shift_map),
             alpha: self.alpha.under_multiple_binders(shift_map),
         }
     }
@@ -68,6 +59,9 @@ impl Binder {
     pub(crate) fn to_label(&self) -> Label {
         self.clone().into()
     }
+    pub(crate) fn name(&self) -> &Label {
+        &self.name
+    }
 }
 
 /// Equality up to alpha-equivalence
@@ -85,7 +79,7 @@ impl std::cmp::PartialEq for Binder {
 
 impl std::fmt::Debug for AlphaVar {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "AlphaVar({}, {})", self.normal, self.alpha.1)
+        write!(f, "AlphaVar({})", self.alpha.1)
     }
 }
 
@@ -97,18 +91,12 @@ impl std::fmt::Debug for Binder {
 
 impl<'a> From<&'a Label> for AlphaVar {
     fn from(x: &'a Label) -> AlphaVar {
-        AlphaVar {
-            normal: V(x.clone(), 0),
-            alpha: V((), 0),
-        }
+        AlphaVar { alpha: V((), 0) }
     }
 }
 impl From<Binder> for AlphaVar {
     fn from(x: Binder) -> AlphaVar {
-        AlphaVar {
-            normal: V(x.into(), 0),
-            alpha: V((), 0),
-        }
+        AlphaVar { alpha: V((), 0) }
     }
 }
 impl<'a> From<&'a Binder> for AlphaVar {
diff --git a/dhall/src/semantics/to_expr.rs b/dhall/src/semantics/to_expr.rs
index 1adfd49..612f794 100644
--- a/dhall/src/semantics/to_expr.rs
+++ b/dhall/src/semantics/to_expr.rs
@@ -1,8 +1,9 @@
+use crate::semantics::core::var::Binder;
 use crate::semantics::phase::typecheck::rc;
 use crate::semantics::phase::NormalizedExpr;
 use crate::semantics::{Value, ValueKind};
 use crate::syntax;
-use crate::syntax::{Builtin, ExprKind};
+use crate::syntax::{Builtin, ExprKind, V};
 
 /// Controls conversion from `Value` to `Expr`
 #[derive(Copy, Clone)]
@@ -14,19 +15,37 @@ pub(crate) struct ToExprOptions {
 }
 
 /// Converts a value back to the corresponding AST expression.
-pub(crate) fn value_to_expr(
-    val: &Value,
+pub(crate) fn value_to_expr<'a>(
+    val: &'a Value,
     opts: ToExprOptions,
+    ctx: &Vec<&'a Binder>,
 ) -> NormalizedExpr {
     if opts.normalize {
         val.normalize_whnf();
     }
 
     let kind = val.as_kind();
-    let kind = kind.map_ref(|v| value_to_expr(v, opts));
+    let kind = kind.map_ref_with_special_handling_of_binders(
+        |v| value_to_expr(v, opts, ctx),
+        |b, _, v| {
+            let mut ctx = ctx.clone();
+            ctx.push(b);
+            value_to_expr(v, opts, &ctx)
+        },
+    );
     match kind {
+        ValueKind::Var(v) if opts.alpha => {
+            rc(ExprKind::Var(V("_".into(), v.idx())))
+        }
         ValueKind::Var(v) => {
-            rc(ExprKind::Var(v.to_var_maybe_alpha(opts.alpha)))
+            let name = ctx[ctx.len() - 1 - v.idx()].to_label();
+            let mut idx = 0;
+            for b in ctx.iter().rev().take(v.idx()) {
+                if b.name() == &name {
+                    idx += 1;
+                }
+            }
+            rc(ExprKind::Var(V(name, idx)))
         }
         ValueKind::Lam(x, t, e) => {
             rc(ExprKind::Lam(x.to_label_maybe_alpha(opts.alpha), t, e))
-- 
cgit v1.2.3


From 0f4a4801ed67826dc82015d39ce8fd05e7950035 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 17 Jan 2020 18:42:13 +0000
Subject: Replace all bulk shifting by a single shift

---
 dhall/src/semantics/core/context.rs | 15 ++++---------
 dhall/src/semantics/core/value.rs   | 45 -------------------------------------
 dhall/src/semantics/core/var.rs     | 20 ++++-------------
 dhall/src/syntax/ast/expr.rs        | 26 ---------------------
 4 files changed, 8 insertions(+), 98 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index f8d6ff0..47d2d2d 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-
 use crate::error::TypeError;
 use crate::semantics::core::value::Value;
 use crate::semantics::core::value::ValueKind;
@@ -40,7 +38,7 @@ impl TyCtx {
     }
     pub fn lookup(&self, var: &V<Label>) -> Option<Value> {
         let mut var = var.clone();
-        let mut shift_map: HashMap<Label, usize> = HashMap::new();
+        let mut shift_delta: isize = 0;
         let mut rev_ctx = self.ctx.iter().rev().map(|(b, i)| (b.to_label(), i));
 
         let found_item = loop {
@@ -50,7 +48,7 @@ impl TyCtx {
                     None => break item,
                 };
                 if let CtxItem::Kept(_, _) = item {
-                    *shift_map.entry(label).or_insert(0) += 1;
+                    shift_delta += 1;
                 }
             } else {
                 // Unbound variable
@@ -65,13 +63,8 @@ impl TyCtx {
             ),
             CtxItem::Replaced(v) => v.clone(),
         };
-
-        let v = v.under_multiple_binders(&shift_map);
-        // for (x, n) in shift_map {
-        //     let x: AlphaVar = (&x).into();
-        //     // Can't fail since delta is positive
-        //     v = v.shift(n as isize, &x).unwrap();
-        // }
+        // Can't fail because delta is positive
+        let v = v.shift(shift_delta, &AlphaVar::default()).unwrap();
         return Some(v);
     }
     // pub fn lookup_alpha(&self, var: &AlphaVar) -> Option<Value> {
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index d843a1b..6ae0a90 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -255,14 +255,6 @@ impl Value {
         // Can't fail since delta is positive
         self.shift(1, &x.into()).unwrap()
     }
-    pub(crate) fn under_multiple_binders(
-        &self,
-        shift_map: &HashMap<Label, usize>,
-    ) -> Self {
-        self.as_internal()
-            .under_multiple_binders(shift_map)
-            .into_value()
-    }
     pub(crate) fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
         match &*self.as_kind() {
             // If the var matches, we can just reuse the provided value instead of copying it.
@@ -369,20 +361,6 @@ impl ValueInternal {
             span: self.span.clone(),
         })
     }
-    fn under_multiple_binders(
-        &self,
-        shift_map: &HashMap<Label, usize>,
-    ) -> Self {
-        ValueInternal {
-            form: self.form,
-            kind: self.kind.under_multiple_binders(shift_map),
-            ty: match &self.ty {
-                None => None,
-                Some(ty) => Some(ty.under_multiple_binders(shift_map)),
-            },
-            span: self.span.clone(),
-        }
-    }
     fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
         ValueInternal {
             // The resulting value may not stay in wnhf after substitution
@@ -482,29 +460,6 @@ impl ValueKind<Value> {
             )?,
         })
     }
-    #[allow(dead_code)]
-    fn under_multiple_binders(
-        &self,
-        shift_map: &HashMap<Label, usize>,
-    ) -> Self {
-        match self {
-            ValueKind::Var(v) => {
-                ValueKind::Var(v.under_multiple_binders(shift_map))
-            }
-            _ => self.map_ref_with_special_handling_of_binders(
-                |v| v.under_multiple_binders(shift_map),
-                |b, _, v| {
-                    let mut v = v.clone();
-                    for (x, n) in shift_map {
-                        let x: AlphaVar = x.into();
-                        // Can't fail since delta is positive
-                        v = v.shift(*n as isize, &x.under_binder(b)).unwrap();
-                    }
-                    v
-                },
-            ),
-        }
-    }
     fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
         match self {
             ValueKind::Var(v) if v == var => val.to_whnf_ignore_type(),
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index f3475e7..93776bf 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-
 use crate::syntax::{Label, V};
 
 /// Stores an alpha-normalized variable.
@@ -16,6 +14,9 @@ pub struct Binder {
 }
 
 impl AlphaVar {
+    pub(crate) fn default() -> Self {
+        AlphaVar { alpha: V((), 0) }
+    }
     pub(crate) fn idx(&self) -> usize {
         self.alpha.idx()
     }
@@ -35,14 +36,6 @@ impl AlphaVar {
     pub(crate) fn over_binder(&self, x: &AlphaVar) -> Option<Self> {
         self.shift(-1, x)
     }
-    pub(crate) fn under_multiple_binders(
-        &self,
-        shift_map: &HashMap<Label, usize>,
-    ) -> Self {
-        AlphaVar {
-            alpha: self.alpha.under_multiple_binders(shift_map),
-        }
-    }
 }
 
 impl Binder {
@@ -89,11 +82,6 @@ impl std::fmt::Debug for Binder {
     }
 }
 
-impl<'a> From<&'a Label> for AlphaVar {
-    fn from(x: &'a Label) -> AlphaVar {
-        AlphaVar { alpha: V((), 0) }
-    }
-}
 impl From<Binder> for AlphaVar {
     fn from(x: Binder) -> AlphaVar {
         AlphaVar { alpha: V((), 0) }
@@ -101,7 +89,7 @@ impl From<Binder> for AlphaVar {
 }
 impl<'a> From<&'a Binder> for AlphaVar {
     fn from(x: &'a Binder) -> AlphaVar {
-        x.clone().into()
+        AlphaVar { alpha: V((), 0) }
     }
 }
 
diff --git a/dhall/src/syntax/ast/expr.rs b/dhall/src/syntax/ast/expr.rs
index 2372b0a..170cbe7 100644
--- a/dhall/src/syntax/ast/expr.rs
+++ b/dhall/src/syntax/ast/expr.rs
@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-
 use crate::syntax::map::{DupTreeMap, DupTreeSet};
 use crate::syntax::visitor::{self, ExprKindMutVisitor, ExprKindVisitor};
 use crate::syntax::*;
@@ -319,30 +317,6 @@ impl<Label: PartialEq + Clone> V<Label> {
     }
 }
 
-impl V<Label> {
-    pub(crate) fn under_multiple_binders(
-        &self,
-        shift_map: &HashMap<Label, usize>,
-    ) -> Self {
-        let name = &self.0;
-        let idx = self.1 + shift_map.get(name).unwrap_or(&0);
-        V(name.clone(), idx)
-    }
-}
-
-impl V<()> {
-    pub(crate) fn under_multiple_binders(
-        &self,
-        shift_map: &HashMap<Label, usize>,
-    ) -> Self {
-        let mut idx = self.1;
-        for (_, n) in shift_map {
-            idx += n;
-        }
-        V((), idx)
-    }
-}
-
 pub fn trivial_result<T>(x: Result<T, !>) -> T {
     match x {
         Ok(x) => x,
-- 
cgit v1.2.3


From b7d847cc812e6a7ce52354b15a9ed6b41ffeb3b4 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 17 Jan 2020 18:57:52 +0000
Subject: Simplify

---
 dhall/src/semantics/core/context.rs    | 12 +++++++-----
 dhall/src/semantics/core/value.rs      | 26 ++++++++++----------------
 dhall/src/semantics/core/var.rs        | 21 ++-------------------
 dhall/src/semantics/phase/normalize.rs |  9 ++++-----
 dhall/src/semantics/phase/typecheck.rs | 22 +++++++++++-----------
 5 files changed, 34 insertions(+), 56 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index 47d2d2d..8c64c26 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -6,7 +6,9 @@ use crate::syntax::{Label, V};
 
 #[derive(Debug, Clone)]
 enum CtxItem {
-    Kept(AlphaVar, Value),
+    // Variable is bound with given type
+    Kept(Value),
+    // Variable has been replaced by corresponding value
     Replaced(Value),
 }
 
@@ -24,7 +26,7 @@ impl TyCtx {
     }
     pub fn insert_type(&self, x: &Binder, t: Value) -> Self {
         let mut vec = self.ctx.clone();
-        vec.push((x.clone(), CtxItem::Kept(x.into(), t.under_binder(x))));
+        vec.push((x.clone(), CtxItem::Kept(t.under_binder())));
         self.with_vec(vec)
     }
     pub fn insert_value(
@@ -47,7 +49,7 @@ impl TyCtx {
                     Some(newvar) => newvar,
                     None => break item,
                 };
-                if let CtxItem::Kept(_, _) = item {
+                if let CtxItem::Kept(_) = item {
                     shift_delta += 1;
                 }
             } else {
@@ -57,8 +59,8 @@ impl TyCtx {
         };
 
         let v = match found_item {
-            CtxItem::Kept(newvar, t) => Value::from_kind_and_type(
-                ValueKind::Var(newvar.clone()),
+            CtxItem::Kept(t) => Value::from_kind_and_type(
+                ValueKind::Var(AlphaVar::default()),
                 t.clone(),
             ),
             CtxItem::Replaced(v) => v.clone(),
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 6ae0a90..8b3ada1 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -209,9 +209,9 @@ impl Value {
 
     pub(crate) fn app(&self, v: Value) -> Value {
         let body_t = match &*self.get_type_not_sort().as_whnf() {
-            ValueKind::Pi(x, t, e) => {
+            ValueKind::Pi(_, t, e) => {
                 v.check_type(t);
-                e.subst_shift(&x.into(), &v)
+                e.subst_shift(&AlphaVar::default(), &v)
             }
             _ => unreachable!("Internal type error"),
         };
@@ -242,18 +242,12 @@ impl Value {
     pub(crate) fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
         Some(self.as_internal().shift(delta, var)?.into_value())
     }
-    pub(crate) fn over_binder<T>(&self, x: T) -> Option<Self>
-    where
-        T: Into<AlphaVar>,
-    {
-        self.shift(-1, &x.into())
+    pub(crate) fn over_binder(&self) -> Option<Self> {
+        self.shift(-1, &AlphaVar::default())
     }
-    pub(crate) fn under_binder<T>(&self, x: T) -> Self
-    where
-        T: Into<AlphaVar>,
-    {
+    pub(crate) fn under_binder(&self) -> Self {
         // Can't fail since delta is positive
-        self.shift(1, &x.into()).unwrap()
+        self.shift(1, &AlphaVar::default()).unwrap()
     }
     pub(crate) fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
         match &*self.as_kind() {
@@ -456,18 +450,18 @@ impl ValueKind<Value> {
             ValueKind::Var(v) => ValueKind::Var(v.shift(delta, var)?),
             _ => self.traverse_ref_with_special_handling_of_binders(
                 |x| Ok(x.shift(delta, var)?),
-                |b, _, x| Ok(x.shift(delta, &var.under_binder(b))?),
+                |_, _, x| Ok(x.shift(delta, &var.under_binder())?),
             )?,
         })
     }
     fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
         match self {
             ValueKind::Var(v) if v == var => val.to_whnf_ignore_type(),
-            ValueKind::Var(v) => ValueKind::Var(v.over_binder(var).unwrap()),
+            ValueKind::Var(v) => ValueKind::Var(v.shift(-1, var).unwrap()),
             _ => self.map_ref_with_special_handling_of_binders(
                 |x| x.subst_shift(var, val),
-                |b, _, x| {
-                    x.subst_shift(&var.under_binder(b), &val.under_binder(b))
+                |_, _, x| {
+                    x.subst_shift(&var.under_binder(), &val.under_binder())
                 },
             ),
         }
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index 93776bf..b336c66 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -26,15 +26,9 @@ impl AlphaVar {
             alpha: self.alpha.shift(delta, &var.alpha)?,
         })
     }
-    pub(crate) fn under_binder<T>(&self, x: T) -> Self
-    where
-        T: Into<AlphaVar>,
-    {
+    pub(crate) fn under_binder(&self) -> Self {
         // Can't fail since delta is positive
-        self.shift(1, &x.into()).unwrap()
-    }
-    pub(crate) fn over_binder(&self, x: &AlphaVar) -> Option<Self> {
-        self.shift(-1, x)
+        self.shift(1, &AlphaVar::default()).unwrap()
     }
 }
 
@@ -82,17 +76,6 @@ impl std::fmt::Debug for Binder {
     }
 }
 
-impl From<Binder> for AlphaVar {
-    fn from(x: Binder) -> AlphaVar {
-        AlphaVar { alpha: V((), 0) }
-    }
-}
-impl<'a> From<&'a Binder> for AlphaVar {
-    fn from(x: &'a Binder) -> AlphaVar {
-        AlphaVar { alpha: V((), 0) }
-    }
-}
-
 impl From<Binder> for Label {
     fn from(x: Binder) -> Label {
         x.name
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index 8f9a58a..541a196 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -1,10 +1,9 @@
 use std::collections::HashMap;
 use std::convert::TryInto;
 
-use crate::semantics::core::value::Value;
-use crate::semantics::core::value::ValueKind;
 use crate::semantics::phase::typecheck::{rc, typecheck};
 use crate::semantics::phase::Normalized;
+use crate::semantics::{AlphaVar, Value, ValueKind};
 use crate::syntax;
 use crate::syntax::Const::Type;
 use crate::syntax::{
@@ -367,9 +366,9 @@ pub(crate) fn apply_builtin(
 pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
     let f_borrow = f.as_whnf();
     match &*f_borrow {
-        ValueKind::Lam(x, _, e) => {
-            e.subst_shift(&x.into(), &a).to_whnf_check_type(ty)
-        }
+        ValueKind::Lam(_, _, e) => e
+            .subst_shift(&AlphaVar::default(), &a)
+            .to_whnf_check_type(ty),
         ValueKind::AppliedBuiltin(b, args) => {
             use std::iter::once;
             let args = args.iter().cloned().chain(once(a.clone())).collect();
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index 852f41b..15025c1 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -6,7 +6,7 @@ use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::context::TyCtx;
 use crate::semantics::phase::normalize::merge_maps;
 use crate::semantics::phase::Normalized;
-use crate::semantics::{Binder, Value, ValueKind};
+use crate::semantics::{AlphaVar, Binder, Value, ValueKind};
 use crate::syntax;
 use crate::syntax::{
     Builtin, Const, Expr, ExprKind, InterpolatedTextContents, Label, Span,
@@ -385,15 +385,15 @@ fn type_last_layer(
         App(f, a) => {
             let tf = f.get_type()?;
             let tf_borrow = tf.as_whnf();
-            let (x, tx, tb) = match &*tf_borrow {
-                ValueKind::Pi(x, tx, tb) => (x, tx, tb),
+            let (tx, tb) = match &*tf_borrow {
+                ValueKind::Pi(_, tx, tb) => (tx, tb),
                 _ => return mkerr(NotAFunction(f.clone())),
             };
             if &a.get_type()? != tx {
                 return mkerr(TypeMismatch(f.clone(), tx.clone(), a.clone()));
             }
 
-            let ret = tb.subst_shift(&x.into(), a);
+            let ret = tb.subst_shift(&AlphaVar::default(), a);
             ret.normalize_nf();
             RetTypeOnly(ret)
         }
@@ -500,13 +500,12 @@ fn type_last_layer(
                         ValueKind::UnionType(kts) => match kts.get(&x) {
                             // Constructor has type T -> < x: T, ... >
                             Some(Some(t)) => {
-                                let x = ctx.new_binder(x);
                                 RetTypeOnly(
                                     tck_pi_type(
                                         ctx,
-                                        x.clone(),
+                                        ctx.new_binder(x),
                                         t.clone(),
-                                        r.under_binder(x),
+                                        r.under_binder(),
                                     )?
                                 )
                             },
@@ -719,8 +718,8 @@ fn type_last_layer(
                         // Union alternative with type
                         Some(Some(variant_type)) => {
                             let handler_type_borrow = handler_type.as_whnf();
-                            let (x, tx, tb) = match &*handler_type_borrow {
-                                ValueKind::Pi(x, tx, tb) => (x, tx, tb),
+                            let (tx, tb) = match &*handler_type_borrow {
+                                ValueKind::Pi(_, tx, tb) => (tx, tb),
                                 _ => {
                                     return mkerr(NotAFunction(
                                         handler_type.clone(),
@@ -736,8 +735,9 @@ fn type_last_layer(
                                 ));
                             }
 
-                            // Extract `tb` from under the `x` binder. Fails is `x` was free in `tb`.
-                            match tb.over_binder(x) {
+                            // Extract `tb` from under the binder. Fails if the variable was used
+                            // in `tb`.
+                            match tb.over_binder() {
                                 Some(x) => x,
                                 None => return mkerr(
                                     MergeHandlerReturnTypeMustNotBeDependent,
-- 
cgit v1.2.3


From ec28905d32c23109da17696faefab284fde3e103 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 18 Jan 2020 18:46:09 +0000
Subject: Introduce intermediate representation that stores typed expr

---
 dhall/src/semantics/core/value.rs |  87 +++++++++++++++++++++++++++++---
 dhall/src/semantics/core/var.rs   |  18 +------
 dhall/src/semantics/mod.rs        |   3 +-
 dhall/src/semantics/phase/mod.rs  |  10 +++-
 dhall/src/semantics/tck/mod.rs    |   2 +
 dhall/src/semantics/tck/tyexpr.rs |  83 +++++++++++++++++++++++++++++++
 dhall/src/semantics/to_expr.rs    | 101 --------------------------------------
 dhall/src/syntax/ast/expr.rs      |   2 +-
 8 files changed, 177 insertions(+), 129 deletions(-)
 create mode 100644 dhall/src/semantics/tck/mod.rs
 create mode 100644 dhall/src/semantics/tck/tyexpr.rs
 delete mode 100644 dhall/src/semantics/to_expr.rs

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 8b3ada1..a1125cd 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -7,10 +7,12 @@ use crate::semantics::core::context::TyCtx;
 use crate::semantics::core::var::{AlphaVar, Binder};
 use crate::semantics::phase::normalize::{apply_any, normalize_whnf};
 use crate::semantics::phase::typecheck::{builtin_to_value, const_to_value};
-use crate::semantics::phase::{Normalized, NormalizedExpr, Typed};
-use crate::semantics::to_expr;
+use crate::semantics::phase::{
+    Normalized, NormalizedExpr, ToExprOptions, Typed,
+};
+use crate::semantics::{TyExpr, TyExprKind};
 use crate::syntax::{
-    Builtin, Const, ExprKind, Integer, InterpolatedTextContents, Label,
+    BinOp, Builtin, Const, ExprKind, Integer, InterpolatedTextContents, Label,
     NaiveDouble, Natural, Span,
 };
 
@@ -159,11 +161,12 @@ impl Value {
     }
 
     /// Converts a value back to the corresponding AST expression.
-    pub(crate) fn to_expr(
-        &self,
-        opts: to_expr::ToExprOptions,
-    ) -> NormalizedExpr {
-        to_expr::value_to_expr(self, opts, &vec![])
+    pub(crate) fn to_expr(&self, opts: ToExprOptions) -> NormalizedExpr {
+        if opts.normalize {
+            self.normalize_nf();
+        }
+
+        self.to_tyexpr().to_expr(opts)
     }
     pub(crate) fn to_whnf_ignore_type(&self) -> ValueKind<Value> {
         self.as_whnf().clone()
@@ -283,6 +286,10 @@ impl Value {
     //         }
     //     }
     // }
+
+    pub fn to_tyexpr(&self) -> TyExpr {
+        value_to_tyexpr(self)
+    }
 }
 
 impl ValueInternal {
@@ -510,6 +517,70 @@ impl<V> ValueKind<V> {
     }
 }
 
+fn value_to_tyexpr(val: &Value) -> TyExpr {
+    let val_kind = val.as_kind();
+    let val_ty = val.as_internal().ty.clone();
+    let val_span = val.as_internal().span.clone();
+    if let ValueKind::Var(v) = &*val_kind {
+        return TyExpr::new(TyExprKind::Var(*v), val_ty, val_span);
+    }
+
+    // TODO: properly recover intermediate types; `None` is a time-bomb here.
+    let rc = |expr| TyExpr::new(TyExprKind::Expr(expr), None, Span::Artificial);
+
+    let val_kind = val_kind.map_ref(|v| v.to_tyexpr());
+    let expr = match val_kind {
+        ValueKind::Var(_) => unreachable!(),
+        ValueKind::Lam(x, t, e) => ExprKind::Lam(x.to_label(), t, e),
+        ValueKind::Pi(x, t, e) => ExprKind::Pi(x.to_label(), t, e),
+        ValueKind::AppliedBuiltin(b, args) => args
+            .into_iter()
+            .fold(ExprKind::Builtin(b), |acc, v| ExprKind::App(rc(acc), v)),
+        ValueKind::Const(c) => ExprKind::Const(c),
+        ValueKind::BoolLit(b) => ExprKind::BoolLit(b),
+        ValueKind::NaturalLit(n) => ExprKind::NaturalLit(n),
+        ValueKind::IntegerLit(n) => ExprKind::IntegerLit(n),
+        ValueKind::DoubleLit(n) => ExprKind::DoubleLit(n),
+        ValueKind::EmptyOptionalLit(n) => {
+            ExprKind::App(rc(ExprKind::Builtin(Builtin::OptionalNone)), n)
+        }
+        ValueKind::NEOptionalLit(n) => ExprKind::SomeLit(n),
+        ValueKind::EmptyListLit(n) => ExprKind::EmptyListLit(rc(
+            ExprKind::App(rc(ExprKind::Builtin(Builtin::List)), n),
+        )),
+        ValueKind::NEListLit(elts) => ExprKind::NEListLit(elts),
+        ValueKind::RecordLit(kvs) => {
+            ExprKind::RecordLit(kvs.into_iter().collect())
+        }
+        ValueKind::RecordType(kts) => {
+            ExprKind::RecordType(kts.into_iter().collect())
+        }
+        ValueKind::UnionType(kts) => {
+            ExprKind::UnionType(kts.into_iter().collect())
+        }
+        ValueKind::UnionConstructor(l, kts) => ExprKind::Field(
+            rc(ExprKind::UnionType(kts.into_iter().collect())),
+            l,
+        ),
+        ValueKind::UnionLit(l, v, kts) => ExprKind::App(
+            rc(ExprKind::Field(
+                rc(ExprKind::UnionType(kts.into_iter().collect())),
+                l,
+            )),
+            v,
+        ),
+        ValueKind::TextLit(elts) => {
+            ExprKind::TextLit(elts.into_iter().collect())
+        }
+        ValueKind::Equivalence(x, y) => {
+            ExprKind::BinOp(BinOp::Equivalence, x, y)
+        }
+        ValueKind::PartialExpr(e) => e,
+    };
+
+    TyExpr::new(TyExprKind::Expr(expr), val_ty, val_span)
+}
+
 // TODO: use Rc comparison to shortcut on identical pointers
 impl std::cmp::PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index b336c66..0aa86d5 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -1,7 +1,7 @@
 use crate::syntax::{Label, V};
 
 /// Stores an alpha-normalized variable.
-#[derive(Clone, Eq)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub struct AlphaVar {
     alpha: V<()>,
 }
@@ -36,27 +36,11 @@ impl Binder {
     pub(crate) fn new(name: Label) -> Self {
         Binder { name }
     }
-    pub(crate) fn to_label_maybe_alpha(&self, alpha: bool) -> Label {
-        if alpha {
-            "_".into()
-        } else {
-            self.to_label()
-        }
-    }
     pub(crate) fn to_label(&self) -> Label {
         self.clone().into()
     }
-    pub(crate) fn name(&self) -> &Label {
-        &self.name
-    }
 }
 
-/// Equality up to alpha-equivalence
-impl std::cmp::PartialEq for AlphaVar {
-    fn eq(&self, other: &Self) -> bool {
-        self.alpha == other.alpha
-    }
-}
 /// Equality up to alpha-equivalence
 impl std::cmp::PartialEq for Binder {
     fn eq(&self, _other: &Self) -> bool {
diff --git a/dhall/src/semantics/mod.rs b/dhall/src/semantics/mod.rs
index 3ef1aba..63f74ee 100644
--- a/dhall/src/semantics/mod.rs
+++ b/dhall/src/semantics/mod.rs
@@ -1,4 +1,5 @@
 pub mod core;
 pub mod phase;
-pub mod to_expr;
+pub mod tck;
 pub(crate) use self::core::*;
+pub(crate) use self::tck::*;
diff --git a/dhall/src/semantics/phase/mod.rs b/dhall/src/semantics/phase/mod.rs
index 6afed88..4dc91e7 100644
--- a/dhall/src/semantics/phase/mod.rs
+++ b/dhall/src/semantics/phase/mod.rs
@@ -4,7 +4,6 @@ use std::path::Path;
 use crate::error::{EncodeError, Error, ImportError, TypeError};
 use crate::semantics::core::value::Value;
 use crate::semantics::core::value::ValueKind;
-use crate::semantics::to_expr::ToExprOptions;
 use crate::syntax::binary;
 use crate::syntax::{Builtin, Const, Expr};
 use resolve::ImportRoot;
@@ -38,6 +37,15 @@ pub struct Typed(Value);
 #[derive(Debug, Clone)]
 pub struct Normalized(Typed);
 
+/// Controls conversion from `Value` to `Expr`
+#[derive(Copy, Clone)]
+pub(crate) struct ToExprOptions {
+    /// Whether to convert all variables to `_`
+    pub(crate) alpha: bool,
+    /// Whether to normalize before converting
+    pub(crate) normalize: bool,
+}
+
 impl Parsed {
     pub fn parse_file(f: &Path) -> Result<Parsed, Error> {
         parse::parse_file(f)
diff --git a/dhall/src/semantics/tck/mod.rs b/dhall/src/semantics/tck/mod.rs
new file mode 100644
index 0000000..407605d
--- /dev/null
+++ b/dhall/src/semantics/tck/mod.rs
@@ -0,0 +1,2 @@
+pub mod tyexpr;
+pub(crate) use tyexpr::*;
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
new file mode 100644
index 0000000..a8b8e58
--- /dev/null
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -0,0 +1,83 @@
+#![allow(dead_code)]
+use crate::semantics::core::var::AlphaVar;
+use crate::semantics::phase::typecheck::rc;
+use crate::semantics::phase::Normalized;
+use crate::semantics::phase::{NormalizedExpr, ToExprOptions};
+use crate::semantics::Value;
+use crate::syntax::{ExprKind, Label, Span, V};
+
+pub(crate) type Type = Value;
+
+// An expression with inferred types at every node and resolved variables.
+pub(crate) struct TyExpr {
+    kind: Box<TyExprKind>,
+    ty: Option<Type>,
+    span: Span,
+}
+
+pub(crate) enum TyExprKind {
+    Var(AlphaVar),
+    // Forbidden ExprKind variants: Var
+    Expr(ExprKind<TyExpr, Normalized>),
+}
+
+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
+    }
+
+    /// Converts a value back to the corresponding AST expression.
+    pub fn to_expr<'a>(&'a self, opts: ToExprOptions) -> NormalizedExpr {
+        tyexpr_to_expr(self, opts, &Vec::new())
+    }
+}
+
+// TODO: mutate context once map_ref gets simplified
+fn tyexpr_to_expr<'a>(
+    tyexpr: &'a TyExpr,
+    opts: ToExprOptions,
+    ctx: &Vec<&'a Label>,
+) -> NormalizedExpr {
+    rc(match tyexpr.kind() {
+        TyExprKind::Var(v) if opts.alpha => {
+            ExprKind::Var(V("_".into(), v.idx()))
+        }
+        TyExprKind::Var(v) => {
+            let name = ctx[ctx.len() - 1 - v.idx()];
+            let mut idx = 0;
+            for l in ctx.iter().rev().take(v.idx()) {
+                if *l == name {
+                    idx += 1;
+                }
+            }
+            ExprKind::Var(V(name.clone(), idx))
+        }
+        TyExprKind::Expr(e) => {
+            let e = e.map_ref_with_special_handling_of_binders(
+                |tye| tyexpr_to_expr(tye, opts, ctx),
+                |l, tye| {
+                    let ctx = ctx.iter().copied().chain(Some(l)).collect();
+                    tyexpr_to_expr(tye, opts, &ctx)
+                },
+            );
+
+            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,
+            }
+        }
+    })
+}
diff --git a/dhall/src/semantics/to_expr.rs b/dhall/src/semantics/to_expr.rs
deleted file mode 100644
index 612f794..0000000
--- a/dhall/src/semantics/to_expr.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-use crate::semantics::core::var::Binder;
-use crate::semantics::phase::typecheck::rc;
-use crate::semantics::phase::NormalizedExpr;
-use crate::semantics::{Value, ValueKind};
-use crate::syntax;
-use crate::syntax::{Builtin, ExprKind, V};
-
-/// Controls conversion from `Value` to `Expr`
-#[derive(Copy, Clone)]
-pub(crate) struct ToExprOptions {
-    /// Whether to convert all variables to `_`
-    pub(crate) alpha: bool,
-    /// Whether to normalize before converting
-    pub(crate) normalize: bool,
-}
-
-/// Converts a value back to the corresponding AST expression.
-pub(crate) fn value_to_expr<'a>(
-    val: &'a Value,
-    opts: ToExprOptions,
-    ctx: &Vec<&'a Binder>,
-) -> NormalizedExpr {
-    if opts.normalize {
-        val.normalize_whnf();
-    }
-
-    let kind = val.as_kind();
-    let kind = kind.map_ref_with_special_handling_of_binders(
-        |v| value_to_expr(v, opts, ctx),
-        |b, _, v| {
-            let mut ctx = ctx.clone();
-            ctx.push(b);
-            value_to_expr(v, opts, &ctx)
-        },
-    );
-    match kind {
-        ValueKind::Var(v) if opts.alpha => {
-            rc(ExprKind::Var(V("_".into(), v.idx())))
-        }
-        ValueKind::Var(v) => {
-            let name = ctx[ctx.len() - 1 - v.idx()].to_label();
-            let mut idx = 0;
-            for b in ctx.iter().rev().take(v.idx()) {
-                if b.name() == &name {
-                    idx += 1;
-                }
-            }
-            rc(ExprKind::Var(V(name, idx)))
-        }
-        ValueKind::Lam(x, t, e) => {
-            rc(ExprKind::Lam(x.to_label_maybe_alpha(opts.alpha), t, e))
-        }
-        ValueKind::AppliedBuiltin(b, args) => args
-            .into_iter()
-            .fold(rc(ExprKind::Builtin(b)), |acc, v| rc(ExprKind::App(acc, v))),
-        ValueKind::Pi(x, t, e) => {
-            rc(ExprKind::Pi(x.to_label_maybe_alpha(opts.alpha), t, e))
-        }
-        ValueKind::Const(c) => rc(ExprKind::Const(c)),
-        ValueKind::BoolLit(b) => rc(ExprKind::BoolLit(b)),
-        ValueKind::NaturalLit(n) => rc(ExprKind::NaturalLit(n)),
-        ValueKind::IntegerLit(n) => rc(ExprKind::IntegerLit(n)),
-        ValueKind::DoubleLit(n) => rc(ExprKind::DoubleLit(n)),
-        ValueKind::EmptyOptionalLit(n) => rc(ExprKind::App(
-            rc(ExprKind::Builtin(Builtin::OptionalNone)),
-            n,
-        )),
-        ValueKind::NEOptionalLit(n) => rc(ExprKind::SomeLit(n)),
-        ValueKind::EmptyListLit(n) => rc(ExprKind::EmptyListLit(rc(
-            ExprKind::App(rc(ExprKind::Builtin(Builtin::List)), n),
-        ))),
-        ValueKind::NEListLit(elts) => rc(ExprKind::NEListLit(elts)),
-        ValueKind::RecordLit(kvs) => {
-            rc(ExprKind::RecordLit(kvs.into_iter().collect()))
-        }
-        ValueKind::RecordType(kts) => {
-            rc(ExprKind::RecordType(kts.into_iter().collect()))
-        }
-        ValueKind::UnionType(kts) => {
-            rc(ExprKind::UnionType(kts.into_iter().collect()))
-        }
-        ValueKind::UnionConstructor(l, kts) => rc(ExprKind::Field(
-            rc(ExprKind::UnionType(kts.into_iter().collect())),
-            l,
-        )),
-        ValueKind::UnionLit(l, v, kts) => rc(ExprKind::App(
-            rc(ExprKind::Field(
-                rc(ExprKind::UnionType(kts.into_iter().collect())),
-                l,
-            )),
-            v,
-        )),
-        ValueKind::TextLit(elts) => {
-            rc(ExprKind::TextLit(elts.into_iter().collect()))
-        }
-        ValueKind::Equivalence(x, y) => {
-            rc(ExprKind::BinOp(syntax::BinOp::Equivalence, x, y))
-        }
-        ValueKind::PartialExpr(e) => rc(e),
-    }
-}
diff --git a/dhall/src/syntax/ast/expr.rs b/dhall/src/syntax/ast/expr.rs
index 170cbe7..f22a279 100644
--- a/dhall/src/syntax/ast/expr.rs
+++ b/dhall/src/syntax/ast/expr.rs
@@ -23,7 +23,7 @@ pub enum Const {
 /// The `Label` field is the variable's name (i.e. \"`x`\").
 /// The `Int` field is a DeBruijn index.
 /// See dhall-lang/standard/semantics.md for details
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct V<Label>(pub Label, pub usize);
 
 // Definition order must match precedence order for
-- 
cgit v1.2.3


From d6e5c56a5ef1d5f2b7cafd4a8fb44ce038932547 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 18 Jan 2020 19:08:34 +0000
Subject: Add Expr visitor and improve tyexpr_to_expr

---
 dhall/src/semantics/tck/tyexpr.rs | 22 +++++++++---------
 dhall/src/syntax/ast/expr.rs      | 47 +++++++++++++++++++++++++++------------
 dhall/src/syntax/ast/visitor.rs   | 39 ++++++--------------------------
 3 files changed, 52 insertions(+), 56 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index a8b8e58..f0fcdd1 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -36,15 +36,14 @@ impl TyExpr {
 
     /// Converts a value back to the corresponding AST expression.
     pub fn to_expr<'a>(&'a self, opts: ToExprOptions) -> NormalizedExpr {
-        tyexpr_to_expr(self, opts, &Vec::new())
+        tyexpr_to_expr(self, opts, &mut Vec::new())
     }
 }
 
-// TODO: mutate context once map_ref gets simplified
 fn tyexpr_to_expr<'a>(
     tyexpr: &'a TyExpr,
     opts: ToExprOptions,
-    ctx: &Vec<&'a Label>,
+    ctx: &mut Vec<&'a Label>,
 ) -> NormalizedExpr {
     rc(match tyexpr.kind() {
         TyExprKind::Var(v) if opts.alpha => {
@@ -61,13 +60,16 @@ fn tyexpr_to_expr<'a>(
             ExprKind::Var(V(name.clone(), idx))
         }
         TyExprKind::Expr(e) => {
-            let e = e.map_ref_with_special_handling_of_binders(
-                |tye| tyexpr_to_expr(tye, opts, ctx),
-                |l, tye| {
-                    let ctx = ctx.iter().copied().chain(Some(l)).collect();
-                    tyexpr_to_expr(tye, opts, &ctx)
-                },
-            );
+            let e = e.map_ref_maybe_binder(|l, tye| {
+                if let Some(l) = l {
+                    ctx.push(l);
+                }
+                let e = tyexpr_to_expr(tye, opts, ctx);
+                if let Some(_) = l {
+                    ctx.pop();
+                }
+                e
+            });
 
             match e {
                 ExprKind::Lam(_, t, e) if opts.alpha => {
diff --git a/dhall/src/syntax/ast/expr.rs b/dhall/src/syntax/ast/expr.rs
index f22a279..dbe233b 100644
--- a/dhall/src/syntax/ast/expr.rs
+++ b/dhall/src/syntax/ast/expr.rs
@@ -180,29 +180,38 @@ impl<Label> V<Label> {
 }
 
 impl<SE, E> ExprKind<SE, E> {
+    pub fn traverse_ref_maybe_binder<'a, SE2, Err>(
+        &'a self,
+        visit: impl FnMut(Option<&'a Label>, &'a SE) -> Result<SE2, Err>,
+    ) -> Result<ExprKind<SE2, E>, Err>
+    where
+        E: Clone,
+    {
+        visitor::TraverseRefMaybeBinderVisitor(visit).visit(self)
+    }
+
     pub fn traverse_ref_with_special_handling_of_binders<'a, SE2, Err>(
         &'a self,
-        visit_subexpr: impl FnMut(&'a SE) -> Result<SE2, Err>,
-        visit_under_binder: impl FnOnce(&'a Label, &'a SE) -> Result<SE2, Err>,
+        mut visit_subexpr: impl FnMut(&'a SE) -> Result<SE2, Err>,
+        mut visit_under_binder: impl FnMut(&'a Label, &'a SE) -> Result<SE2, Err>,
     ) -> Result<ExprKind<SE2, E>, Err>
     where
         E: Clone,
     {
-        visitor::TraverseRefWithBindersVisitor {
-            visit_subexpr,
-            visit_under_binder,
-        }
-        .visit(self)
+        self.traverse_ref_maybe_binder(|l, x| match l {
+            None => visit_subexpr(x),
+            Some(l) => visit_under_binder(l, x),
+        })
     }
 
     pub(crate) fn traverse_ref<'a, SE2, Err>(
         &'a self,
-        visit_subexpr: impl FnMut(&'a SE) -> Result<SE2, Err>,
+        mut visit_subexpr: impl FnMut(&'a SE) -> Result<SE2, Err>,
     ) -> Result<ExprKind<SE2, E>, Err>
     where
         E: Clone,
     {
-        visitor::TraverseRefVisitor { visit_subexpr }.visit(self)
+        self.traverse_ref_maybe_binder(|_, e| visit_subexpr(e))
     }
 
     fn traverse_mut<'a, Err>(
@@ -212,6 +221,16 @@ impl<SE, E> ExprKind<SE, E> {
         visitor::TraverseMutVisitor { visit_subexpr }.visit(self)
     }
 
+    pub fn map_ref_maybe_binder<'a, SE2>(
+        &'a self,
+        mut map: impl FnMut(Option<&'a Label>, &'a SE) -> SE2,
+    ) -> ExprKind<SE2, E>
+    where
+        E: Clone,
+    {
+        trivial_result(self.traverse_ref_maybe_binder(|l, x| Ok(map(l, x))))
+    }
+
     pub fn map_ref_with_special_handling_of_binders<'a, SE2>(
         &'a self,
         mut map_subexpr: impl FnMut(&'a SE) -> SE2,
@@ -220,10 +239,10 @@ impl<SE, E> ExprKind<SE, E> {
     where
         E: Clone,
     {
-        trivial_result(self.traverse_ref_with_special_handling_of_binders(
-            |x| Ok(map_subexpr(x)),
-            |l, x| Ok(map_under_binder(l, x)),
-        ))
+        self.map_ref_maybe_binder(|l, x| match l {
+            None => map_subexpr(x),
+            Some(l) => map_under_binder(l, x),
+        })
     }
 
     pub fn map_ref<'a, SE2>(
@@ -233,7 +252,7 @@ impl<SE, E> ExprKind<SE, E> {
     where
         E: Clone,
     {
-        trivial_result(self.traverse_ref(|x| Ok(map_subexpr(x))))
+        self.map_ref_maybe_binder(|_, e| map_subexpr(e))
     }
 
     pub fn map_mut<'a>(&'a mut self, mut map_subexpr: impl FnMut(&'a mut SE)) {
diff --git a/dhall/src/syntax/ast/visitor.rs b/dhall/src/syntax/ast/visitor.rs
index f9fd379..6a1ce7d 100644
--- a/dhall/src/syntax/ast/visitor.rs
+++ b/dhall/src/syntax/ast/visitor.rs
@@ -296,51 +296,26 @@ where
     Ok(())
 }
 
-pub struct TraverseRefWithBindersVisitor<F1, F2> {
-    pub visit_subexpr: F1,
-    pub visit_under_binder: F2,
-}
+pub struct TraverseRefMaybeBinderVisitor<F>(pub F);
 
-impl<'a, SE, E, SE2, Err, F1, F2> ExprKindVisitor<'a, SE, SE2, E, E>
-    for TraverseRefWithBindersVisitor<F1, F2>
+impl<'a, SE, E, SE2, Err, F> ExprKindVisitor<'a, SE, SE2, E, E>
+    for TraverseRefMaybeBinderVisitor<F>
 where
     SE: 'a,
     E: 'a + Clone,
-    F1: FnMut(&'a SE) -> Result<SE2, Err>,
-    F2: FnOnce(&'a Label, &'a SE) -> Result<SE2, Err>,
+    F: FnMut(Option<&'a Label>, &'a SE) -> Result<SE2, Err>,
 {
     type Error = Err;
 
     fn visit_subexpr(&mut self, subexpr: &'a SE) -> Result<SE2, Self::Error> {
-        (self.visit_subexpr)(subexpr)
+        (self.0)(None, subexpr)
     }
     fn visit_subexpr_under_binder(
-        self,
+        mut self,
         label: &'a Label,
         subexpr: &'a SE,
     ) -> Result<SE2, Self::Error> {
-        (self.visit_under_binder)(label, subexpr)
-    }
-    fn visit_embed(self, embed: &'a E) -> Result<E, Self::Error> {
-        Ok(embed.clone())
-    }
-}
-
-pub struct TraverseRefVisitor<F1> {
-    pub visit_subexpr: F1,
-}
-
-impl<'a, SE, E, SE2, Err, F1> ExprKindVisitor<'a, SE, SE2, E, E>
-    for TraverseRefVisitor<F1>
-where
-    SE: 'a,
-    E: 'a + Clone,
-    F1: FnMut(&'a SE) -> Result<SE2, Err>,
-{
-    type Error = Err;
-
-    fn visit_subexpr(&mut self, subexpr: &'a SE) -> Result<SE2, Self::Error> {
-        (self.visit_subexpr)(subexpr)
+        (self.0)(Some(label), subexpr)
     }
     fn visit_embed(self, embed: &'a E) -> Result<E, Self::Error> {
         Ok(embed.clone())
-- 
cgit v1.2.3


From 2f19fe1978c0fc8c456563c68ca08eb5b48ef0cd Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 18 Jan 2020 19:30:53 +0000
Subject: fixup! Introduce intermediate representation that stores typed expr

---
 dhall/src/semantics/core/value.rs | 127 +++++++++++++++++++-------------------
 1 file changed, 62 insertions(+), 65 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index a1125cd..7086616 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -288,7 +288,68 @@ impl Value {
     // }
 
     pub fn to_tyexpr(&self) -> TyExpr {
-        value_to_tyexpr(self)
+        let self_kind = self.as_kind();
+        let self_ty = self.as_internal().ty.clone();
+        let self_span = self.as_internal().span.clone();
+        if let ValueKind::Var(v) = &*self_kind {
+            return TyExpr::new(TyExprKind::Var(*v), self_ty, self_span);
+        }
+
+        // TODO: properly recover intermediate types; `None` is a time-bomb here.
+        let rc =
+            |expr| TyExpr::new(TyExprKind::Expr(expr), None, Span::Artificial);
+
+        let self_kind = self_kind.map_ref(|v| v.to_tyexpr());
+        let expr = match self_kind {
+            ValueKind::Var(_) => unreachable!(),
+            ValueKind::Lam(x, t, e) => ExprKind::Lam(x.to_label(), t, e),
+            ValueKind::Pi(x, t, e) => ExprKind::Pi(x.to_label(), t, e),
+            ValueKind::AppliedBuiltin(b, args) => args
+                .into_iter()
+                .fold(ExprKind::Builtin(b), |acc, v| ExprKind::App(rc(acc), v)),
+            ValueKind::Const(c) => ExprKind::Const(c),
+            ValueKind::BoolLit(b) => ExprKind::BoolLit(b),
+            ValueKind::NaturalLit(n) => ExprKind::NaturalLit(n),
+            ValueKind::IntegerLit(n) => ExprKind::IntegerLit(n),
+            ValueKind::DoubleLit(n) => ExprKind::DoubleLit(n),
+            ValueKind::EmptyOptionalLit(n) => {
+                ExprKind::App(rc(ExprKind::Builtin(Builtin::OptionalNone)), n)
+            }
+            ValueKind::NEOptionalLit(n) => ExprKind::SomeLit(n),
+            ValueKind::EmptyListLit(n) => ExprKind::EmptyListLit(rc(
+                ExprKind::App(rc(ExprKind::Builtin(Builtin::List)), n),
+            )),
+            ValueKind::NEListLit(elts) => ExprKind::NEListLit(elts),
+            ValueKind::RecordLit(kvs) => {
+                ExprKind::RecordLit(kvs.into_iter().collect())
+            }
+            ValueKind::RecordType(kts) => {
+                ExprKind::RecordType(kts.into_iter().collect())
+            }
+            ValueKind::UnionType(kts) => {
+                ExprKind::UnionType(kts.into_iter().collect())
+            }
+            ValueKind::UnionConstructor(l, kts) => ExprKind::Field(
+                rc(ExprKind::UnionType(kts.into_iter().collect())),
+                l,
+            ),
+            ValueKind::UnionLit(l, v, kts) => ExprKind::App(
+                rc(ExprKind::Field(
+                    rc(ExprKind::UnionType(kts.into_iter().collect())),
+                    l,
+                )),
+                v,
+            ),
+            ValueKind::TextLit(elts) => {
+                ExprKind::TextLit(elts.into_iter().collect())
+            }
+            ValueKind::Equivalence(x, y) => {
+                ExprKind::BinOp(BinOp::Equivalence, x, y)
+            }
+            ValueKind::PartialExpr(e) => e,
+        };
+
+        TyExpr::new(TyExprKind::Expr(expr), self_ty, self_span)
     }
 }
 
@@ -517,70 +578,6 @@ impl<V> ValueKind<V> {
     }
 }
 
-fn value_to_tyexpr(val: &Value) -> TyExpr {
-    let val_kind = val.as_kind();
-    let val_ty = val.as_internal().ty.clone();
-    let val_span = val.as_internal().span.clone();
-    if let ValueKind::Var(v) = &*val_kind {
-        return TyExpr::new(TyExprKind::Var(*v), val_ty, val_span);
-    }
-
-    // TODO: properly recover intermediate types; `None` is a time-bomb here.
-    let rc = |expr| TyExpr::new(TyExprKind::Expr(expr), None, Span::Artificial);
-
-    let val_kind = val_kind.map_ref(|v| v.to_tyexpr());
-    let expr = match val_kind {
-        ValueKind::Var(_) => unreachable!(),
-        ValueKind::Lam(x, t, e) => ExprKind::Lam(x.to_label(), t, e),
-        ValueKind::Pi(x, t, e) => ExprKind::Pi(x.to_label(), t, e),
-        ValueKind::AppliedBuiltin(b, args) => args
-            .into_iter()
-            .fold(ExprKind::Builtin(b), |acc, v| ExprKind::App(rc(acc), v)),
-        ValueKind::Const(c) => ExprKind::Const(c),
-        ValueKind::BoolLit(b) => ExprKind::BoolLit(b),
-        ValueKind::NaturalLit(n) => ExprKind::NaturalLit(n),
-        ValueKind::IntegerLit(n) => ExprKind::IntegerLit(n),
-        ValueKind::DoubleLit(n) => ExprKind::DoubleLit(n),
-        ValueKind::EmptyOptionalLit(n) => {
-            ExprKind::App(rc(ExprKind::Builtin(Builtin::OptionalNone)), n)
-        }
-        ValueKind::NEOptionalLit(n) => ExprKind::SomeLit(n),
-        ValueKind::EmptyListLit(n) => ExprKind::EmptyListLit(rc(
-            ExprKind::App(rc(ExprKind::Builtin(Builtin::List)), n),
-        )),
-        ValueKind::NEListLit(elts) => ExprKind::NEListLit(elts),
-        ValueKind::RecordLit(kvs) => {
-            ExprKind::RecordLit(kvs.into_iter().collect())
-        }
-        ValueKind::RecordType(kts) => {
-            ExprKind::RecordType(kts.into_iter().collect())
-        }
-        ValueKind::UnionType(kts) => {
-            ExprKind::UnionType(kts.into_iter().collect())
-        }
-        ValueKind::UnionConstructor(l, kts) => ExprKind::Field(
-            rc(ExprKind::UnionType(kts.into_iter().collect())),
-            l,
-        ),
-        ValueKind::UnionLit(l, v, kts) => ExprKind::App(
-            rc(ExprKind::Field(
-                rc(ExprKind::UnionType(kts.into_iter().collect())),
-                l,
-            )),
-            v,
-        ),
-        ValueKind::TextLit(elts) => {
-            ExprKind::TextLit(elts.into_iter().collect())
-        }
-        ValueKind::Equivalence(x, y) => {
-            ExprKind::BinOp(BinOp::Equivalence, x, y)
-        }
-        ValueKind::PartialExpr(e) => e,
-    };
-
-    TyExpr::new(TyExprKind::Expr(expr), val_ty, val_span)
-}
-
 // TODO: use Rc comparison to shortcut on identical pointers
 impl std::cmp::PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {
-- 
cgit v1.2.3


From aec80599f161096b68cac88ffb8852a61b62fcfa Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 19 Jan 2020 18:30:13 +0000
Subject: Restore more types in value_to_tyexpr

---
 dhall/src/semantics/core/value.rs      | 77 ++++++++++++++++++++++++----------
 dhall/src/semantics/core/visitor.rs    | 14 ++++---
 dhall/src/semantics/phase/normalize.rs | 23 ++++++----
 dhall/src/semantics/tck/mod.rs         |  2 +
 dhall/src/semantics/tck/tyexpr.rs      | 14 ++++++-
 5 files changed, 93 insertions(+), 37 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 7086616..f470019 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -10,7 +10,7 @@ use crate::semantics::phase::typecheck::{builtin_to_value, const_to_value};
 use crate::semantics::phase::{
     Normalized, NormalizedExpr, ToExprOptions, Typed,
 };
-use crate::semantics::{TyExpr, TyExprKind};
+use crate::semantics::{TyExpr, TyExprKind, Type};
 use crate::syntax::{
     BinOp, Builtin, Const, ExprKind, Integer, InterpolatedTextContents, Label,
     NaiveDouble, Natural, Span,
@@ -75,8 +75,10 @@ pub(crate) enum ValueKind<Value> {
     RecordType(HashMap<Label, Value>),
     RecordLit(HashMap<Label, Value>),
     UnionType(HashMap<Label, Option<Value>>),
-    UnionConstructor(Label, HashMap<Label, Option<Value>>),
-    UnionLit(Label, Value, HashMap<Label, Option<Value>>),
+    // Also keep the type of the uniontype around
+    UnionConstructor(Label, HashMap<Label, Option<Value>>, Type),
+    // Also keep the type of the uniontype and the constructor around
+    UnionLit(Label, Value, HashMap<Label, Option<Value>>, Type, Type),
     // Invariant: in whnf, this must not contain interpolations that are themselves TextLits, and
     // contiguous text values must be merged.
     TextLit(Vec<InterpolatedTextContents<Value>>),
@@ -296,28 +298,40 @@ impl Value {
         }
 
         // TODO: properly recover intermediate types; `None` is a time-bomb here.
-        let rc =
-            |expr| TyExpr::new(TyExprKind::Expr(expr), None, Span::Artificial);
-
         let self_kind = self_kind.map_ref(|v| v.to_tyexpr());
         let expr = match self_kind {
             ValueKind::Var(_) => unreachable!(),
             ValueKind::Lam(x, t, e) => ExprKind::Lam(x.to_label(), t, e),
             ValueKind::Pi(x, t, e) => ExprKind::Pi(x.to_label(), t, e),
-            ValueKind::AppliedBuiltin(b, args) => args
-                .into_iter()
-                .fold(ExprKind::Builtin(b), |acc, v| ExprKind::App(rc(acc), v)),
+            ValueKind::AppliedBuiltin(b, args) => {
+                args.into_iter().fold(ExprKind::Builtin(b), |acc, v| {
+                    ExprKind::App(
+                        TyExpr::new(
+                            TyExprKind::Expr(acc),
+                            None, // TODO
+                            Span::Artificial,
+                        ),
+                        v,
+                    )
+                })
+            }
             ValueKind::Const(c) => ExprKind::Const(c),
             ValueKind::BoolLit(b) => ExprKind::BoolLit(b),
             ValueKind::NaturalLit(n) => ExprKind::NaturalLit(n),
             ValueKind::IntegerLit(n) => ExprKind::IntegerLit(n),
             ValueKind::DoubleLit(n) => ExprKind::DoubleLit(n),
-            ValueKind::EmptyOptionalLit(n) => {
-                ExprKind::App(rc(ExprKind::Builtin(Builtin::OptionalNone)), n)
-            }
+            ValueKind::EmptyOptionalLit(n) => ExprKind::App(
+                builtin_to_value(Builtin::OptionalNone).to_tyexpr(),
+                n,
+            ),
             ValueKind::NEOptionalLit(n) => ExprKind::SomeLit(n),
-            ValueKind::EmptyListLit(n) => ExprKind::EmptyListLit(rc(
-                ExprKind::App(rc(ExprKind::Builtin(Builtin::List)), n),
+            ValueKind::EmptyListLit(n) => ExprKind::EmptyListLit(TyExpr::new(
+                TyExprKind::Expr(ExprKind::App(
+                    builtin_to_value(Builtin::List).to_tyexpr(),
+                    n,
+                )),
+                Some(const_to_value(Const::Type)),
+                Span::Artificial,
             )),
             ValueKind::NEListLit(elts) => ExprKind::NEListLit(elts),
             ValueKind::RecordLit(kvs) => {
@@ -329,15 +343,31 @@ impl Value {
             ValueKind::UnionType(kts) => {
                 ExprKind::UnionType(kts.into_iter().collect())
             }
-            ValueKind::UnionConstructor(l, kts) => ExprKind::Field(
-                rc(ExprKind::UnionType(kts.into_iter().collect())),
+            ValueKind::UnionConstructor(l, kts, t) => ExprKind::Field(
+                TyExpr::new(
+                    TyExprKind::Expr(ExprKind::UnionType(
+                        kts.into_iter().collect(),
+                    )),
+                    Some(t),
+                    Span::Artificial,
+                ),
                 l,
             ),
-            ValueKind::UnionLit(l, v, kts) => ExprKind::App(
-                rc(ExprKind::Field(
-                    rc(ExprKind::UnionType(kts.into_iter().collect())),
-                    l,
-                )),
+            ValueKind::UnionLit(l, v, kts, uniont, ctort) => ExprKind::App(
+                TyExpr::new(
+                    TyExprKind::Expr(ExprKind::Field(
+                        TyExpr::new(
+                            TyExprKind::Expr(ExprKind::UnionType(
+                                kts.into_iter().collect(),
+                            )),
+                            Some(uniont),
+                            Span::Artificial,
+                        ),
+                        l,
+                    )),
+                    Some(ctort),
+                    Span::Artificial,
+                ),
                 v,
             ),
             ValueKind::TextLit(elts) => {
@@ -483,12 +513,13 @@ impl ValueKind<Value> {
                     x.normalize_mut();
                 }
             }
-            ValueKind::UnionType(kts) | ValueKind::UnionConstructor(_, kts) => {
+            ValueKind::UnionType(kts)
+            | ValueKind::UnionConstructor(_, kts, _) => {
                 for x in kts.values_mut().flat_map(|opt| opt) {
                     x.normalize_mut();
                 }
             }
-            ValueKind::UnionLit(_, v, kts) => {
+            ValueKind::UnionLit(_, v, kts, _, _) => {
                 v.normalize_mut();
                 for x in kts.values_mut().flat_map(|opt| opt) {
                     x.normalize_mut();
diff --git a/dhall/src/semantics/core/visitor.rs b/dhall/src/semantics/core/visitor.rs
index e61a649..a449f6c 100644
--- a/dhall/src/semantics/core/visitor.rs
+++ b/dhall/src/semantics/core/visitor.rs
@@ -94,12 +94,16 @@ where
         RecordType(kts) => RecordType(v.visit_map(kts)?),
         RecordLit(kvs) => RecordLit(v.visit_map(kvs)?),
         UnionType(kts) => UnionType(v.visit_optmap(kts)?),
-        UnionConstructor(l, kts) => {
-            UnionConstructor(l.clone(), v.visit_optmap(kts)?)
-        }
-        UnionLit(l, t, kts) => {
-            UnionLit(l.clone(), v.visit_val(t)?, v.visit_optmap(kts)?)
+        UnionConstructor(l, kts, t) => {
+            UnionConstructor(l.clone(), v.visit_optmap(kts)?, t.clone())
         }
+        UnionLit(l, x, kts, uniont, ctort) => UnionLit(
+            l.clone(),
+            v.visit_val(x)?,
+            v.visit_optmap(kts)?,
+            uniont.clone(),
+            ctort.clone(),
+        ),
         TextLit(ts) => TextLit(
             ts.iter()
                 .map(|t| t.traverse_ref(|e| v.visit_val(e)))
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index 541a196..f0a6a8c 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -374,9 +374,13 @@ pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
             let args = args.iter().cloned().chain(once(a.clone())).collect();
             apply_builtin(*b, args, ty)
         }
-        ValueKind::UnionConstructor(l, kts) => {
-            ValueKind::UnionLit(l.clone(), a, kts.clone())
-        }
+        ValueKind::UnionConstructor(l, kts, uniont) => ValueKind::UnionLit(
+            l.clone(),
+            a,
+            kts.clone(),
+            uniont.clone(),
+            f.get_type().unwrap(),
+        ),
         _ => {
             drop(f_borrow);
             ValueKind::PartialExpr(ExprKind::App(f, a))
@@ -692,9 +696,11 @@ pub(crate) fn normalize_one_layer(
                         Ret::Expr(expr)
                     }
                 },
-                UnionType(kts) => {
-                    Ret::ValueKind(UnionConstructor(l.clone(), kts.clone()))
-                }
+                UnionType(kts) => Ret::ValueKind(UnionConstructor(
+                    l.clone(),
+                    kts.clone(),
+                    v.get_type().unwrap(),
+                )),
                 _ => {
                     drop(v_borrow);
                     Ret::Expr(expr)
@@ -710,7 +716,8 @@ pub(crate) fn normalize_one_layer(
             let handlers_borrow = handlers.as_whnf();
             let variant_borrow = variant.as_whnf();
             match (&*handlers_borrow, &*variant_borrow) {
-                (RecordLit(kvs), UnionConstructor(l, _)) => match kvs.get(l) {
+                (RecordLit(kvs), UnionConstructor(l, _, _)) => match kvs.get(l)
+                {
                     Some(h) => Ret::Value(h.clone()),
                     None => {
                         drop(handlers_borrow);
@@ -718,7 +725,7 @@ pub(crate) fn normalize_one_layer(
                         Ret::Expr(expr)
                     }
                 },
-                (RecordLit(kvs), UnionLit(l, v, _)) => match kvs.get(l) {
+                (RecordLit(kvs), UnionLit(l, v, _, _, _)) => match kvs.get(l) {
                     Some(h) => Ret::Value(h.app(v.clone())),
                     None => {
                         drop(handlers_borrow);
diff --git a/dhall/src/semantics/tck/mod.rs b/dhall/src/semantics/tck/mod.rs
index 407605d..ba95847 100644
--- a/dhall/src/semantics/tck/mod.rs
+++ b/dhall/src/semantics/tck/mod.rs
@@ -1,2 +1,4 @@
+pub mod context;
 pub mod tyexpr;
+pub mod typecheck;
 pub(crate) use tyexpr::*;
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index f0fcdd1..36cae04 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -1,4 +1,6 @@
 #![allow(dead_code)]
+use crate::error::{TypeError, TypeMessage};
+use crate::semantics::core::context::TyCtx;
 use crate::semantics::core::var::AlphaVar;
 use crate::semantics::phase::typecheck::rc;
 use crate::semantics::phase::Normalized;
@@ -33,11 +35,21 @@ impl TyExpr {
     pub fn kind(&self) -> &TyExprKind {
         &*self.kind
     }
+    pub fn get_type(&self) -> Result<Type, TypeError> {
+        match &self.ty {
+            Some(t) => Ok(t.clone()),
+            None => Err(TypeError::new(&TyCtx::new(), TypeMessage::Sort)),
+        }
+    }
 
     /// Converts a value back to the corresponding AST expression.
-    pub fn to_expr<'a>(&'a self, opts: ToExprOptions) -> NormalizedExpr {
+    pub fn to_expr(&self, opts: ToExprOptions) -> NormalizedExpr {
         tyexpr_to_expr(self, opts, &mut Vec::new())
     }
+    // TODO: temporary hack
+    pub fn to_value(&self) -> Value {
+        todo!()
+    }
 }
 
 fn tyexpr_to_expr<'a>(
-- 
cgit v1.2.3


From c448698f797f2304dca0e0b8b833959de00ca079 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 20 Jan 2020 15:27:19 +0000
Subject: Reimplement basic tck/nze with proper environments

Inspired from dhall_haskell
---
 dhall/src/error/mod.rs            |   5 +
 dhall/src/semantics/core/var.rs   |   3 +
 dhall/src/semantics/mod.rs        |   1 +
 dhall/src/semantics/nze/mod.rs    |   2 +
 dhall/src/semantics/nze/nzexpr.rs | 399 ++++++++++++++++++++++++++++++++++++++
 dhall/src/semantics/tck/tyexpr.rs |  16 +-
 dhall/src/tests.rs                |  19 +-
 7 files changed, 432 insertions(+), 13 deletions(-)
 create mode 100644 dhall/src/semantics/nze/mod.rs
 create mode 100644 dhall/src/semantics/nze/nzexpr.rs

(limited to 'dhall')

diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index 56bc8ab..844a3e4 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -174,3 +174,8 @@ impl From<TypeError> for Error {
         Error::Typecheck(err)
     }
 }
+impl From<crate::semantics::nze::nzexpr::TypeError> for Error {
+    fn from(_: crate::semantics::nze::nzexpr::TypeError) -> Error {
+        Error::Decode(DecodeError::WrongFormatError("type error".to_string()))
+    }
+}
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index 0aa86d5..0d2c1d4 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -14,6 +14,9 @@ pub struct Binder {
 }
 
 impl AlphaVar {
+    pub(crate) fn new(alpha: V<()>) -> Self {
+        AlphaVar { alpha }
+    }
     pub(crate) fn default() -> Self {
         AlphaVar { alpha: V((), 0) }
     }
diff --git a/dhall/src/semantics/mod.rs b/dhall/src/semantics/mod.rs
index 63f74ee..1304502 100644
--- a/dhall/src/semantics/mod.rs
+++ b/dhall/src/semantics/mod.rs
@@ -1,4 +1,5 @@
 pub mod core;
+pub mod nze;
 pub mod phase;
 pub mod tck;
 pub(crate) use self::core::*;
diff --git a/dhall/src/semantics/nze/mod.rs b/dhall/src/semantics/nze/mod.rs
new file mode 100644
index 0000000..ef8918f
--- /dev/null
+++ b/dhall/src/semantics/nze/mod.rs
@@ -0,0 +1,2 @@
+pub mod nzexpr;
+// pub(crate) use nzexpr::*;
diff --git a/dhall/src/semantics/nze/nzexpr.rs b/dhall/src/semantics/nze/nzexpr.rs
new file mode 100644
index 0000000..2f27dcb
--- /dev/null
+++ b/dhall/src/semantics/nze/nzexpr.rs
@@ -0,0 +1,399 @@
+#![allow(dead_code)]
+use crate::semantics::core::var::AlphaVar;
+use crate::semantics::phase::typecheck::rc;
+use crate::semantics::phase::{Normalized, NormalizedExpr, ToExprOptions};
+use crate::syntax::{Expr, ExprKind, Label, V};
+
+pub(crate) type Type = NzExpr;
+#[derive(Debug, Clone)]
+pub(crate) struct TypeError;
+pub(crate) type Binder = Label;
+
+// An expression with inferred types at every node and resolved variables.
+#[derive(Debug, Clone)]
+pub(crate) struct TyExpr {
+    kind: Box<TyExprKind>,
+    ty: Option<Type>,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum TyExprKind {
+    Var(AlphaVar),
+    Expr(ExprKind<TyExpr, Normalized>),
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct NzExpr {
+    kind: Box<NzExprKind>,
+    ty: Option<Box<Type>>,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum NzExprKind {
+    Var {
+        var: NzVar,
+    },
+    Lam {
+        binder: Binder,
+        annot: NzExpr,
+        env: TyEnv,
+        body: TyExpr,
+    },
+    Pi {
+        binder: Binder,
+        annot: NzExpr,
+        env: TyEnv,
+        body: TyExpr,
+    },
+    Expr(ExprKind<NzExpr, Normalized>),
+    // Unevaled {
+    //     env: TyEnv,
+    //     expr: TyExprKind,
+    // },
+}
+
+#[derive(Debug, Clone)]
+enum TyEnvItem {
+    // Variable is bound with given type
+    Kept(Type),
+    // Variable has been replaced by corresponding value
+    Replaced(NzExpr),
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct TyEnv {
+    env: Vec<(Binder, TyEnvItem)>,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct QuoteEnv {
+    size: usize,
+}
+
+// Reverse-debruijn index: counts number of binders from the bottom of the stack.
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct NzVar {
+    idx: usize,
+}
+
+impl TyEnv {
+    pub fn new() -> Self {
+        TyEnv { env: Vec::new() }
+    }
+    pub fn to_quoteenv(&self) -> QuoteEnv {
+        QuoteEnv {
+            size: self.env.len(),
+        }
+    }
+    fn with_vec(&self, vec: Vec<(Binder, TyEnvItem)>) -> Self {
+        TyEnv { env: vec }
+    }
+
+    pub fn insert_type(&self, x: &Binder, t: NzExpr) -> Self {
+        let mut vec = self.env.clone();
+        vec.push((x.clone(), TyEnvItem::Kept(t)));
+        self.with_vec(vec)
+    }
+    pub fn insert_value(&self, x: &Binder, e: NzExpr) -> Self {
+        let mut vec = self.env.clone();
+        vec.push((x.clone(), TyEnvItem::Replaced(e)));
+        self.with_vec(vec)
+    }
+    pub fn lookup_var(&self, var: &V<Binder>) -> Option<TyExpr> {
+        let V(name, idx) = var;
+        let (idx, (_, item)) = self
+            .env
+            .iter()
+            .rev()
+            .enumerate()
+            .filter(|(_, (x, _))| x == name)
+            .nth(*idx)?;
+        let ty = match item {
+            TyEnvItem::Kept(ty) => ty.clone(),
+            TyEnvItem::Replaced(e) => e.get_type().unwrap(),
+        };
+        Some(TyExpr::new(
+            TyExprKind::Var(AlphaVar::new(V((), idx))),
+            Some(ty),
+        ))
+    }
+    pub fn lookup_val(&self, var: &AlphaVar) -> NzExpr {
+        let idx = self.env.len() - 1 - var.idx();
+        match &self.env[idx].1 {
+            TyEnvItem::Kept(ty) => NzExpr::new(
+                NzExprKind::Var { var: NzVar { idx } },
+                Some(ty.clone()),
+            ),
+            TyEnvItem::Replaced(x) => x.clone(),
+        }
+    }
+    pub fn size(&self) -> usize {
+        self.env.len()
+    }
+}
+
+impl QuoteEnv {
+    pub fn new() -> Self {
+        QuoteEnv { size: 0 }
+    }
+    pub fn insert(&self) -> Self {
+        QuoteEnv {
+            size: self.size + 1,
+        }
+    }
+    pub fn lookup(&self, var: &NzVar) -> AlphaVar {
+        AlphaVar::new(V((), self.size - var.idx - 1))
+    }
+}
+
+impl TyExpr {
+    pub fn new(kind: TyExprKind, ty: Option<Type>) -> Self {
+        TyExpr {
+            kind: Box::new(kind),
+            ty,
+        }
+    }
+
+    pub fn kind(&self) -> &TyExprKind {
+        self.kind.as_ref()
+    }
+    pub fn get_type(&self) -> Result<Type, TypeError> {
+        match &self.ty {
+            Some(t) => Ok(t.clone()),
+            None => Err(TypeError),
+        }
+    }
+
+    /// Converts a value back to the corresponding AST expression.
+    pub fn to_expr(&self, opts: ToExprOptions) -> NormalizedExpr {
+        fn tyexpr_to_expr<'a>(
+            tyexpr: &'a TyExpr,
+            opts: ToExprOptions,
+            env: &mut Vec<&'a Binder>,
+        ) -> NormalizedExpr {
+            rc(match tyexpr.kind() {
+                TyExprKind::Var(var) if opts.alpha => {
+                    ExprKind::Var(V("_".into(), var.idx()))
+                }
+                TyExprKind::Var(var) => {
+                    let name = env[env.len() - 1 - var.idx()];
+                    let idx = env
+                        .iter()
+                        .rev()
+                        .take(var.idx())
+                        .filter(|l| **l == name)
+                        .count();
+                    ExprKind::Var(V(name.clone(), idx))
+                }
+                TyExprKind::Expr(e) => {
+                    let e = e.map_ref_maybe_binder(|l, tye| {
+                        if let Some(l) = l {
+                            env.push(l);
+                        }
+                        let e = tyexpr_to_expr(tye, opts, env);
+                        if let Some(_) = l {
+                            env.pop();
+                        }
+                        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,
+                    }
+                }
+            })
+        }
+
+        tyexpr_to_expr(self, opts, &mut Vec::new())
+    }
+
+    pub fn normalize_nf(&self, env: &TyEnv) -> NzExpr {
+        let kind = match self.kind() {
+            TyExprKind::Var(var) => return env.lookup_val(var),
+            TyExprKind::Expr(ExprKind::Lam(binder, annot, body)) => {
+                NzExprKind::Lam {
+                    binder: binder.clone(),
+                    annot: annot.normalize_nf(env),
+                    env: env.clone(),
+                    body: body.clone(),
+                }
+            }
+            TyExprKind::Expr(ExprKind::Pi(binder, annot, body)) => {
+                NzExprKind::Pi {
+                    binder: binder.clone(),
+                    annot: annot.normalize_nf(env),
+                    env: env.clone(),
+                    body: body.clone(),
+                }
+            }
+            TyExprKind::Expr(e) => {
+                let e = e.map_ref(|tye| tye.normalize_nf(env));
+                match e {
+                    ExprKind::App(f, arg) => match f.kind() {
+                        NzExprKind::Lam {
+                            binder, env, body, ..
+                        } => {
+                            return body
+                                .normalize_nf(&env.insert_value(binder, arg))
+                        }
+                        _ => NzExprKind::Expr(ExprKind::App(f, arg)),
+                    },
+                    _ => NzExprKind::Expr(e),
+                }
+            }
+        };
+        let ty = self.ty.clone();
+        NzExpr::new(kind, ty)
+    }
+
+    pub fn normalize(&self) -> NzExpr {
+        self.normalize_nf(&TyEnv::new())
+    }
+}
+
+impl NzExpr {
+    pub fn new(kind: NzExprKind, ty: Option<Type>) -> Self {
+        NzExpr {
+            kind: Box::new(kind),
+            ty: ty.map(Box::new),
+        }
+    }
+
+    pub fn kind(&self) -> &NzExprKind {
+        self.kind.as_ref()
+    }
+    pub fn get_type(&self) -> Result<Type, TypeError> {
+        match &self.ty {
+            Some(t) => Ok(t.as_ref().clone()),
+            None => Err(TypeError),
+        }
+    }
+
+    pub fn quote(&self, qenv: QuoteEnv) -> TyExpr {
+        let ty = self.ty.as_ref().map(|t| (**t).clone());
+        let kind = match self.kind.as_ref() {
+            NzExprKind::Var { var } => TyExprKind::Var(qenv.lookup(var)),
+            NzExprKind::Lam {
+                binder,
+                annot,
+                env,
+                body,
+            } => TyExprKind::Expr(ExprKind::Lam(
+                binder.clone(),
+                annot.quote(qenv),
+                body.normalize_nf(&env.insert_type(binder, annot.clone()))
+                    .quote(qenv.insert()),
+            )),
+            NzExprKind::Pi {
+                binder,
+                annot,
+                env,
+                body,
+            } => TyExprKind::Expr(ExprKind::Pi(
+                binder.clone(),
+                annot.quote(qenv),
+                body.normalize_nf(&env.insert_type(binder, annot.clone()))
+                    .quote(qenv.insert()),
+            )),
+            NzExprKind::Expr(e) => {
+                TyExprKind::Expr(e.map_ref(|nze| nze.quote(qenv)))
+            } // NzExprKind::Unevaled { env, expr } => {
+              //     return TyExpr::new(expr.clone(), ty.clone())
+              //         .normalize_nf(env)
+              //         .quote(qenv)
+              // }
+        };
+        TyExpr::new(kind, ty)
+    }
+    pub fn to_expr(&self) -> NormalizedExpr {
+        self.quote(QuoteEnv::new()).to_expr(ToExprOptions {
+            alpha: false,
+            normalize: false,
+        })
+    }
+}
+
+/// Type-check an expression and return the expression alongside its type if type-checking
+/// succeeded, or an error if type-checking failed.
+fn type_with(env: &TyEnv, e: Expr<Normalized>) -> Result<TyExpr, TypeError> {
+    match e.as_ref() {
+        ExprKind::Var(var) => match env.lookup_var(&var) {
+            Some(x) => Ok(x),
+            None => Err(TypeError),
+        },
+        ExprKind::Lam(binder, annot, body) => {
+            let annot = type_with(env, annot.clone())?;
+            let annot_nf = annot.normalize_nf(env);
+            let body = type_with(
+                &env.insert_type(&binder, annot_nf.clone()),
+                body.clone(),
+            )?;
+            let ty = NzExpr::new(
+                NzExprKind::Pi {
+                    binder: binder.clone(),
+                    annot: annot_nf,
+                    env: env.clone(),
+                    body: body.get_type()?.quote(env.to_quoteenv()),
+                },
+                None, // TODO: function_check
+            );
+            Ok(TyExpr::new(
+                TyExprKind::Expr(ExprKind::Lam(binder.clone(), annot, body)),
+                Some(ty),
+            ))
+        }
+        ExprKind::Pi(binder, annot, body) => {
+            let annot = type_with(env, annot.clone())?;
+            let annot_nf = annot.normalize_nf(env);
+            let body = type_with(
+                &env.insert_type(&binder, annot_nf.clone()),
+                body.clone(),
+            )?;
+            Ok(TyExpr::new(
+                TyExprKind::Expr(ExprKind::Pi(binder.clone(), annot, body)),
+                None, // TODO: function_check
+            ))
+        }
+        ExprKind::App(f, arg) => {
+            let f = type_with(env, f.clone())?;
+            let arg = type_with(env, arg.clone())?;
+            let tf = f.get_type()?;
+            let (binder, _expected_arg_ty, body_env, body_ty) = match tf.kind()
+            {
+                NzExprKind::Pi {
+                    binder,
+                    annot,
+                    env,
+                    body,
+                } => (binder, annot, env, body),
+                _ => return Err(TypeError),
+            };
+            // if arg.get_type()? != *expected_arg_ty {
+            //     return Err(TypeError);
+            // }
+
+            let arg_nf = arg.normalize_nf(env);
+            let ty =
+                body_ty.normalize_nf(&body_env.insert_value(&binder, arg_nf));
+
+            Ok(TyExpr::new(
+                TyExprKind::Expr(ExprKind::App(f, arg)),
+                Some(ty),
+            ))
+        }
+        e => Ok(TyExpr::new(
+            TyExprKind::Expr(e.traverse_ref(|e| type_with(env, e.clone()))?),
+            None,
+        )),
+    }
+}
+
+pub(crate) fn typecheck(e: Expr<Normalized>) -> Result<TyExpr, TypeError> {
+    type_with(&TyEnv::new(), e)
+}
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index 36cae04..72f5b1d 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -11,15 +11,17 @@ use crate::syntax::{ExprKind, Label, Span, V};
 pub(crate) type Type = Value;
 
 // An expression with inferred types at every node and resolved variables.
+#[derive(Debug, Clone)]
 pub(crate) struct TyExpr {
     kind: Box<TyExprKind>,
     ty: Option<Type>,
     span: Span,
 }
 
+#[derive(Debug, Clone)]
 pub(crate) enum TyExprKind {
     Var(AlphaVar),
-    // Forbidden ExprKind variants: Var
+    // Forbidden ExprKind variants: Var, Import, Embed
     Expr(ExprKind<TyExpr, Normalized>),
 }
 
@@ -63,12 +65,12 @@ fn tyexpr_to_expr<'a>(
         }
         TyExprKind::Var(v) => {
             let name = ctx[ctx.len() - 1 - v.idx()];
-            let mut idx = 0;
-            for l in ctx.iter().rev().take(v.idx()) {
-                if *l == name {
-                    idx += 1;
-                }
-            }
+            let idx = ctx
+                .iter()
+                .rev()
+                .take(v.idx())
+                .filter(|l| **l == name)
+                .count();
             ExprKind::Var(V(name.clone(), idx))
         }
         TyExprKind::Expr(e) => {
diff --git a/dhall/src/tests.rs b/dhall/src/tests.rs
index f1648cf..d86574a 100644
--- a/dhall/src/tests.rs
+++ b/dhall/src/tests.rs
@@ -158,9 +158,12 @@ pub fn run_test(test: Test<'_>) -> Result<()> {
             parse_file_str(&file_path)?.resolve().unwrap_err();
         }
         TypeInferenceSuccess(expr_file_path, expected_file_path) => {
-            let expr =
-                parse_file_str(&expr_file_path)?.resolve()?.typecheck()?;
-            let ty = expr.get_type()?.to_expr();
+            // let expr =
+            //     parse_file_str(&expr_file_path)?.resolve()?.typecheck()?;
+            // let ty = expr.get_type()?.to_expr();
+            let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
+            let tyexpr = crate::semantics::nze::nzexpr::typecheck(expr)?;
+            let ty = tyexpr.get_type()?.to_expr();
             let expected = parse_file_str(&expected_file_path)?.to_expr();
             assert_eq_display!(ty, expected);
         }
@@ -203,9 +206,13 @@ pub fn run_test(test: Test<'_>) -> Result<()> {
             }
         }
         Normalization(expr_file_path, expected_file_path) => {
-            let expr = parse_file_str(&expr_file_path)?
-                .resolve()?
-                .typecheck()?
+            // let expr = parse_file_str(&expr_file_path)?
+            //     .resolve()?
+            //     .typecheck()?
+            //     .normalize()
+            //     .to_expr();
+            let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
+            let expr = crate::semantics::nze::nzexpr::typecheck(expr)?
                 .normalize()
                 .to_expr();
             let expected = parse_file_str(&expected_file_path)?.to_expr();
-- 
cgit v1.2.3


From 476ef4594c9e8c7121bd8fc303e74ef8207a88f4 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 20 Jan 2020 16:17:48 +0000
Subject: Split TyEnv into two envs

---
 dhall/src/semantics/nze/nzexpr.rs | 254 +++++++++++++++++++++++---------------
 1 file changed, 152 insertions(+), 102 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/nze/nzexpr.rs b/dhall/src/semantics/nze/nzexpr.rs
index 2f27dcb..3a5a1f9 100644
--- a/dhall/src/semantics/nze/nzexpr.rs
+++ b/dhall/src/semantics/nze/nzexpr.rs
@@ -36,24 +36,24 @@ pub(crate) enum NzExprKind {
     Lam {
         binder: Binder,
         annot: NzExpr,
-        env: TyEnv,
+        env: NzEnv,
         body: TyExpr,
     },
     Pi {
         binder: Binder,
         annot: NzExpr,
-        env: TyEnv,
+        env: NzEnv,
         body: TyExpr,
     },
     Expr(ExprKind<NzExpr, Normalized>),
     // Unevaled {
-    //     env: TyEnv,
+    //     env: NzEnv,
     //     expr: TyExprKind,
     // },
 }
 
 #[derive(Debug, Clone)]
-enum TyEnvItem {
+enum NzEnvItem {
     // Variable is bound with given type
     Kept(Type),
     // Variable has been replaced by corresponding value
@@ -62,7 +62,18 @@ enum TyEnvItem {
 
 #[derive(Debug, Clone)]
 pub(crate) struct TyEnv {
-    env: Vec<(Binder, TyEnvItem)>,
+    names: NameEnv,
+    items: NzEnv,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct NzEnv {
+    items: Vec<NzEnvItem>,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct NameEnv {
+    names: Vec<Binder>,
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -78,58 +89,120 @@ pub(crate) struct NzVar {
 
 impl TyEnv {
     pub fn new() -> Self {
-        TyEnv { env: Vec::new() }
-    }
-    pub fn to_quoteenv(&self) -> QuoteEnv {
-        QuoteEnv {
-            size: self.env.len(),
+        TyEnv {
+            names: NameEnv::new(),
+            items: NzEnv::new(),
         }
     }
-    fn with_vec(&self, vec: Vec<(Binder, TyEnvItem)>) -> Self {
-        TyEnv { env: vec }
+    pub fn as_quoteenv(&self) -> QuoteEnv {
+        self.names.as_quoteenv()
+    }
+    pub fn as_nzenv(&self) -> &NzEnv {
+        &self.items
+    }
+    pub fn as_nameenv(&self) -> &NameEnv {
+        &self.names
     }
 
     pub fn insert_type(&self, x: &Binder, t: NzExpr) -> Self {
-        let mut vec = self.env.clone();
-        vec.push((x.clone(), TyEnvItem::Kept(t)));
-        self.with_vec(vec)
+        TyEnv {
+            names: self.names.insert(x),
+            items: self.items.insert_type(t),
+        }
     }
     pub fn insert_value(&self, x: &Binder, e: NzExpr) -> Self {
-        let mut vec = self.env.clone();
-        vec.push((x.clone(), TyEnvItem::Replaced(e)));
-        self.with_vec(vec)
+        TyEnv {
+            names: self.names.insert(x),
+            items: self.items.insert_value(e),
+        }
     }
     pub fn lookup_var(&self, var: &V<Binder>) -> Option<TyExpr> {
+        let var = self.names.unlabel_var(var)?;
+        let ty = self.lookup_val(&var).get_type().unwrap();
+        Some(TyExpr::new(TyExprKind::Var(var), Some(ty)))
+    }
+    pub fn lookup_val(&self, var: &AlphaVar) -> NzExpr {
+        self.items.lookup_val(var)
+    }
+    pub fn size(&self) -> usize {
+        self.names.size()
+    }
+}
+
+impl NameEnv {
+    pub fn new() -> Self {
+        NameEnv { names: Vec::new() }
+    }
+    pub fn as_quoteenv(&self) -> QuoteEnv {
+        QuoteEnv {
+            size: self.names.len(),
+        }
+    }
+
+    pub fn insert(&self, x: &Binder) -> Self {
+        let mut env = self.clone();
+        env.insert_mut(x);
+        env
+    }
+    pub fn insert_mut(&mut self, x: &Binder) {
+        self.names.push(x.clone())
+    }
+    pub fn remove_mut(&mut self) {
+        self.names.pop();
+    }
+
+    pub fn unlabel_var(&self, var: &V<Binder>) -> Option<AlphaVar> {
         let V(name, idx) = var;
-        let (idx, (_, item)) = self
-            .env
+        let (idx, _) = self
+            .names
             .iter()
             .rev()
             .enumerate()
-            .filter(|(_, (x, _))| x == name)
+            .filter(|(_, n)| *n == name)
             .nth(*idx)?;
-        let ty = match item {
-            TyEnvItem::Kept(ty) => ty.clone(),
-            TyEnvItem::Replaced(e) => e.get_type().unwrap(),
-        };
-        Some(TyExpr::new(
-            TyExprKind::Var(AlphaVar::new(V((), idx))),
-            Some(ty),
-        ))
+        Some(AlphaVar::new(V((), idx)))
+    }
+    pub fn label_var(&self, var: &AlphaVar) -> V<Binder> {
+        let name = &self.names[self.names.len() - 1 - var.idx()];
+        let idx = self
+            .names
+            .iter()
+            .rev()
+            .take(var.idx())
+            .filter(|n| *n == name)
+            .count();
+        V(name.clone(), idx)
+    }
+    pub fn size(&self) -> usize {
+        self.names.len()
+    }
+}
+
+impl NzEnv {
+    pub fn new() -> Self {
+        NzEnv { items: Vec::new() }
+    }
+
+    pub fn insert_type(&self, t: NzExpr) -> Self {
+        let mut env = self.clone();
+        env.items.push(NzEnvItem::Kept(t));
+        env
+    }
+    pub fn insert_value(&self, e: NzExpr) -> Self {
+        let mut env = self.clone();
+        env.items.push(NzEnvItem::Replaced(e));
+        env
     }
     pub fn lookup_val(&self, var: &AlphaVar) -> NzExpr {
-        let idx = self.env.len() - 1 - var.idx();
-        match &self.env[idx].1 {
-            TyEnvItem::Kept(ty) => NzExpr::new(
+        let idx = self.items.len() - 1 - var.idx();
+        match &self.items[idx] {
+            NzEnvItem::Kept(ty) => NzExpr::new(
                 NzExprKind::Var { var: NzVar { idx } },
                 Some(ty.clone()),
             ),
-            TyEnvItem::Replaced(x) => x.clone(),
+            NzEnvItem::Replaced(x) => x.clone(),
         }
     }
-    pub fn size(&self) -> usize {
-        self.env.len()
-    }
 }
 
 impl QuoteEnv {
@@ -166,54 +239,39 @@ impl TyExpr {
 
     /// Converts a value back to the corresponding AST expression.
     pub fn to_expr(&self, opts: ToExprOptions) -> NormalizedExpr {
-        fn tyexpr_to_expr<'a>(
-            tyexpr: &'a TyExpr,
-            opts: ToExprOptions,
-            env: &mut Vec<&'a Binder>,
-        ) -> NormalizedExpr {
-            rc(match tyexpr.kind() {
-                TyExprKind::Var(var) if opts.alpha => {
-                    ExprKind::Var(V("_".into(), var.idx()))
-                }
-                TyExprKind::Var(var) => {
-                    let name = env[env.len() - 1 - var.idx()];
-                    let idx = env
-                        .iter()
-                        .rev()
-                        .take(var.idx())
-                        .filter(|l| **l == name)
-                        .count();
-                    ExprKind::Var(V(name.clone(), idx))
+        if opts.alpha {
+            self.to_expr_alpha()
+        } else {
+            self.to_expr_noalpha(&mut NameEnv::new())
+        }
+    }
+    fn to_expr_noalpha(&self, env: &mut NameEnv) -> NormalizedExpr {
+        rc(match self.kind() {
+            TyExprKind::Var(var) => ExprKind::Var(env.label_var(var)),
+            TyExprKind::Expr(e) => e.map_ref_maybe_binder(|l, tye| {
+                if let Some(l) = l {
+                    env.insert_mut(l);
                 }
-                TyExprKind::Expr(e) => {
-                    let e = e.map_ref_maybe_binder(|l, tye| {
-                        if let Some(l) = l {
-                            env.push(l);
-                        }
-                        let e = tyexpr_to_expr(tye, opts, env);
-                        if let Some(_) = l {
-                            env.pop();
-                        }
-                        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,
-                    }
+                let e = tye.to_expr_noalpha(env);
+                if let Some(_) = l {
+                    env.remove_mut();
                 }
-            })
-        }
-
-        tyexpr_to_expr(self, opts, &mut Vec::new())
+                e
+            }),
+        })
+    }
+    fn to_expr_alpha(&self) -> NormalizedExpr {
+        rc(match self.kind() {
+            TyExprKind::Var(var) => ExprKind::Var(V("_".into(), var.idx())),
+            TyExprKind::Expr(e) => match e.map_ref(TyExpr::to_expr_alpha) {
+                ExprKind::Lam(_, t, e) => ExprKind::Lam("_".into(), t, e),
+                ExprKind::Pi(_, t, e) => ExprKind::Pi("_".into(), t, e),
+                e => e,
+            },
+        })
     }
 
-    pub fn normalize_nf(&self, env: &TyEnv) -> NzExpr {
+    pub fn normalize_nf(&self, env: &NzEnv) -> NzExpr {
         let kind = match self.kind() {
             TyExprKind::Var(var) => return env.lookup_val(var),
             TyExprKind::Expr(ExprKind::Lam(binder, annot, body)) => {
@@ -236,11 +294,8 @@ impl TyExpr {
                 let e = e.map_ref(|tye| tye.normalize_nf(env));
                 match e {
                     ExprKind::App(f, arg) => match f.kind() {
-                        NzExprKind::Lam {
-                            binder, env, body, ..
-                        } => {
-                            return body
-                                .normalize_nf(&env.insert_value(binder, arg))
+                        NzExprKind::Lam { env, body, .. } => {
+                            return body.normalize_nf(&env.insert_value(arg))
                         }
                         _ => NzExprKind::Expr(ExprKind::App(f, arg)),
                     },
@@ -253,7 +308,7 @@ impl TyExpr {
     }
 
     pub fn normalize(&self) -> NzExpr {
-        self.normalize_nf(&TyEnv::new())
+        self.normalize_nf(&NzEnv::new())
     }
 }
 
@@ -287,7 +342,7 @@ impl NzExpr {
             } => TyExprKind::Expr(ExprKind::Lam(
                 binder.clone(),
                 annot.quote(qenv),
-                body.normalize_nf(&env.insert_type(binder, annot.clone()))
+                body.normalize_nf(&env.insert_type(annot.clone()))
                     .quote(qenv.insert()),
             )),
             NzExprKind::Pi {
@@ -298,7 +353,7 @@ impl NzExpr {
             } => TyExprKind::Expr(ExprKind::Pi(
                 binder.clone(),
                 annot.quote(qenv),
-                body.normalize_nf(&env.insert_type(binder, annot.clone()))
+                body.normalize_nf(&env.insert_type(annot.clone()))
                     .quote(qenv.insert()),
             )),
             NzExprKind::Expr(e) => {
@@ -329,7 +384,7 @@ fn type_with(env: &TyEnv, e: Expr<Normalized>) -> Result<TyExpr, TypeError> {
         },
         ExprKind::Lam(binder, annot, body) => {
             let annot = type_with(env, annot.clone())?;
-            let annot_nf = annot.normalize_nf(env);
+            let annot_nf = annot.normalize_nf(env.as_nzenv());
             let body = type_with(
                 &env.insert_type(&binder, annot_nf.clone()),
                 body.clone(),
@@ -338,8 +393,8 @@ fn type_with(env: &TyEnv, e: Expr<Normalized>) -> Result<TyExpr, TypeError> {
                 NzExprKind::Pi {
                     binder: binder.clone(),
                     annot: annot_nf,
-                    env: env.clone(),
-                    body: body.get_type()?.quote(env.to_quoteenv()),
+                    env: env.as_nzenv().clone(),
+                    body: body.get_type()?.quote(env.as_quoteenv()),
                 },
                 None, // TODO: function_check
             );
@@ -350,7 +405,7 @@ fn type_with(env: &TyEnv, e: Expr<Normalized>) -> Result<TyExpr, TypeError> {
         }
         ExprKind::Pi(binder, annot, body) => {
             let annot = type_with(env, annot.clone())?;
-            let annot_nf = annot.normalize_nf(env);
+            let annot_nf = annot.normalize_nf(env.as_nzenv());
             let body = type_with(
                 &env.insert_type(&binder, annot_nf.clone()),
                 body.clone(),
@@ -364,23 +419,18 @@ fn type_with(env: &TyEnv, e: Expr<Normalized>) -> Result<TyExpr, TypeError> {
             let f = type_with(env, f.clone())?;
             let arg = type_with(env, arg.clone())?;
             let tf = f.get_type()?;
-            let (binder, _expected_arg_ty, body_env, body_ty) = match tf.kind()
-            {
+            let (_expected_arg_ty, body_env, body_ty) = match tf.kind() {
                 NzExprKind::Pi {
-                    binder,
-                    annot,
-                    env,
-                    body,
-                } => (binder, annot, env, body),
+                    annot, env, body, ..
+                } => (annot, env, body),
                 _ => return Err(TypeError),
             };
             // if arg.get_type()? != *expected_arg_ty {
             //     return Err(TypeError);
             // }
 
-            let arg_nf = arg.normalize_nf(env);
-            let ty =
-                body_ty.normalize_nf(&body_env.insert_value(&binder, arg_nf));
+            let arg_nf = arg.normalize_nf(env.as_nzenv());
+            let ty = body_ty.normalize_nf(&body_env.insert_value(arg_nf));
 
             Ok(TyExpr::new(
                 TyExprKind::Expr(ExprKind::App(f, arg)),
-- 
cgit v1.2.3


From 015b24b04128cbf5a60fbc8ac3f526306ca27378 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 21 Jan 2020 17:43:44 +0000
Subject: Simplify type error type

---
 dhall/src/error/mod.rs                 | 13 ++++-------
 dhall/src/semantics/core/value.rs      |  3 +--
 dhall/src/semantics/phase/typecheck.rs | 42 ++++++++++------------------------
 dhall/src/semantics/tck/tyexpr.rs      |  3 +--
 dhall/src/tests.rs                     | 26 ++++++++++-----------
 5 files changed, 31 insertions(+), 56 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index 844a3e4..5595c53 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -1,6 +1,5 @@
 use std::io::Error as IOError;
 
-use crate::semantics::core::context::TyCtx;
 use crate::semantics::core::value::Value;
 use crate::semantics::phase::resolve::ImportStack;
 use crate::semantics::phase::NormalizedExpr;
@@ -37,11 +36,10 @@ pub enum EncodeError {
     CBORError(serde_cbor::error::Error),
 }
 
-/// A structured type error that includes context
+/// A structured type error
 #[derive(Debug)]
 pub struct TypeError {
     message: TypeMessage,
-    context: TyCtx,
 }
 
 /// The specific type error
@@ -88,11 +86,8 @@ pub(crate) enum TypeMessage {
 }
 
 impl TypeError {
-    pub(crate) fn new(context: &TyCtx, message: TypeMessage) -> Self {
-        TypeError {
-            context: context.clone(),
-            message,
-        }
+    pub(crate) fn new(message: TypeMessage) -> Self {
+        TypeError { message }
     }
 }
 
@@ -100,7 +95,7 @@ impl std::fmt::Display for TypeError {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         use TypeMessage::*;
         let msg = match &self.message {
-            UnboundVariable(span) => span.error("Type error: Unbound variable"),
+            UnboundVariable(var) => var.error("Type error: Unbound variable"),
             InvalidInputType(v) => {
                 v.span().error("Type error: Invalid function input")
             }
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index f470019..dc6a116 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -3,7 +3,6 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
-use crate::semantics::core::context::TyCtx;
 use crate::semantics::core::var::{AlphaVar, Binder};
 use crate::semantics::phase::normalize::{apply_any, normalize_whnf};
 use crate::semantics::phase::typecheck::{builtin_to_value, const_to_value};
@@ -438,7 +437,7 @@ impl ValueInternal {
     fn get_type(&self) -> Result<&Value, TypeError> {
         match &self.ty {
             Some(t) => Ok(t),
-            None => Err(TypeError::new(&TyCtx::new(), TypeMessage::Sort)),
+            None => Err(TypeError::new(TypeMessage::Sort)),
         }
     }
 
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index 15025c1..9e41f1e 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -14,27 +14,20 @@ use crate::syntax::{
 };
 
 fn tck_pi_type(
-    ctx: &TyCtx,
     binder: Binder,
     tx: Value,
     te: Value,
 ) -> Result<Value, TypeError> {
     use TypeMessage::*;
-    let ctx2 = ctx.insert_type(&binder, tx.clone());
 
     let ka = match tx.get_type()?.as_const() {
         Some(k) => k,
-        _ => return Err(TypeError::new(ctx, InvalidInputType(tx))),
+        _ => return Err(TypeError::new(InvalidInputType(tx))),
     };
 
     let kb = match te.get_type()?.as_const() {
         Some(k) => k,
-        _ => {
-            return Err(TypeError::new(
-                &ctx2,
-                InvalidOutputType(te.get_type()?),
-            ))
-        }
+        _ => return Err(TypeError::new(InvalidOutputType(te.get_type()?))),
     };
 
     let k = function_check(ka, kb);
@@ -46,7 +39,6 @@ fn tck_pi_type(
 }
 
 fn tck_record_type(
-    ctx: &TyCtx,
     kts: impl IntoIterator<Item = Result<(Label, Value), TypeError>>,
 ) -> Result<Value, TypeError> {
     use std::collections::hash_map::Entry;
@@ -59,13 +51,13 @@ fn tck_record_type(
         // Construct the union of the contained `Const`s
         match t.get_type()?.as_const() {
             Some(k2) => k = max(k, k2),
-            None => return Err(TypeError::new(ctx, InvalidFieldType(x, t))),
+            None => return Err(TypeError::new(InvalidFieldType(x, t))),
         }
         // Check for duplicated entries
         let entry = new_kts.entry(x);
         match &entry {
             Entry::Occupied(_) => {
-                return Err(TypeError::new(ctx, RecordTypeDuplicateField))
+                return Err(TypeError::new(RecordTypeDuplicateField))
             }
             Entry::Vacant(_) => entry.or_insert_with(|| t),
         };
@@ -77,7 +69,7 @@ fn tck_record_type(
     ))
 }
 
-fn tck_union_type<Iter>(ctx: &TyCtx, kts: Iter) -> Result<Value, TypeError>
+fn tck_union_type<Iter>(kts: Iter) -> Result<Value, TypeError>
 where
     Iter: IntoIterator<Item = Result<(Label, Option<Value>), TypeError>>,
 {
@@ -93,17 +85,14 @@ where
                 (None, Some(k2)) => k = Some(k2),
                 (Some(k1), Some(k2)) if k1 == k2 => {}
                 _ => {
-                    return Err(TypeError::new(
-                        ctx,
-                        InvalidFieldType(x, t.clone()),
-                    ))
+                    return Err(TypeError::new(InvalidFieldType(x, t.clone())))
                 }
             }
         }
         let entry = new_kts.entry(x);
         match &entry {
             Entry::Occupied(_) => {
-                return Err(TypeError::new(ctx, UnionTypeDuplicateField))
+                return Err(TypeError::new(UnionTypeDuplicateField))
             }
             Entry::Vacant(_) => entry.or_insert_with(|| t),
         };
@@ -313,7 +302,7 @@ fn type_with(ctx: &TyCtx, e: Expr<Normalized>) -> Result<Value, TypeError> {
             let body_type = body.get_type()?;
             Ok(Value::from_kind_and_type(
                 ValueKind::Lam(binder.clone(), annot.clone(), body),
-                tck_pi_type(ctx, binder, annot, body_type)?,
+                tck_pi_type(binder, annot, body_type)?,
             ))
         }
         Pi(x, ta, tb) => {
@@ -321,7 +310,7 @@ fn type_with(ctx: &TyCtx, e: Expr<Normalized>) -> Result<Value, TypeError> {
             let ta = type_with(ctx, ta.clone())?;
             let ctx2 = ctx.insert_type(&binder, ta.clone());
             let tb = type_with(&ctx2, tb.clone())?;
-            tck_pi_type(ctx, binder, ta, tb)
+            tck_pi_type(binder, ta, tb)
         }
         Let(x, t, v, e) => {
             let v = if let Some(t) = t {
@@ -337,9 +326,7 @@ fn type_with(ctx: &TyCtx, e: Expr<Normalized>) -> Result<Value, TypeError> {
         Embed(p) => Ok(p.clone().into_typed().into_value()),
         Var(var) => match ctx.lookup(&var) {
             Some(typed) => Ok(typed.clone()),
-            None => {
-                Err(TypeError::new(ctx, TypeMessage::UnboundVariable(span)))
-            }
+            None => Err(TypeError::new(TypeMessage::UnboundVariable(span))),
         },
         e => {
             // Typecheck recursively all subexpressions
@@ -364,7 +351,7 @@ fn type_last_layer(
     use syntax::Const::Type;
     use syntax::ExprKind::*;
     use TypeMessage::*;
-    let mkerr = |msg: TypeMessage| Err(TypeError::new(ctx, msg));
+    let mkerr = |msg: TypeMessage| Err(TypeError::new(msg));
 
     /// Intermediary return type
     enum Ret {
@@ -474,15 +461,12 @@ fn type_last_layer(
             RetTypeOnly(Value::from_builtin(syntax::Builtin::Optional).app(t))
         }
         RecordType(kts) => RetWhole(tck_record_type(
-            ctx,
             kts.iter().map(|(x, t)| Ok((x.clone(), t.clone()))),
         )?),
         UnionType(kts) => RetWhole(tck_union_type(
-            ctx,
             kts.iter().map(|(x, t)| Ok((x.clone(), t.clone()))),
         )?),
         RecordLit(kvs) => RetTypeOnly(tck_record_type(
-            ctx,
             kvs.iter().map(|(x, v)| Ok((x.clone(), v.get_type()?))),
         )?),
         Field(r, x) => {
@@ -502,7 +486,6 @@ fn type_last_layer(
                             Some(Some(t)) => {
                                 RetTypeOnly(
                                     tck_pi_type(
-                                        ctx,
                                         ctx.new_binder(x),
                                         t.clone(),
                                         r.under_binder(),
@@ -577,7 +560,6 @@ fn type_last_layer(
 
             // Construct the final record type from the union
             RetTypeOnly(tck_record_type(
-                ctx,
                 kts.into_iter().map(|(x, v)| Ok((x.clone(), v))),
             )?)
         }
@@ -627,7 +609,7 @@ fn type_last_layer(
                 },
             )?;
 
-            RetWhole(tck_record_type(ctx, kts.into_iter().map(Ok))?)
+            RetWhole(tck_record_type(kts.into_iter().map(Ok))?)
         }
         BinOp(o @ ListAppend, l, r) => {
             match &*l.get_type()?.as_whnf() {
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index 72f5b1d..983f3f8 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -1,6 +1,5 @@
 #![allow(dead_code)]
 use crate::error::{TypeError, TypeMessage};
-use crate::semantics::core::context::TyCtx;
 use crate::semantics::core::var::AlphaVar;
 use crate::semantics::phase::typecheck::rc;
 use crate::semantics::phase::Normalized;
@@ -40,7 +39,7 @@ impl TyExpr {
     pub fn get_type(&self) -> Result<Type, TypeError> {
         match &self.ty {
             Some(t) => Ok(t.clone()),
-            None => Err(TypeError::new(&TyCtx::new(), TypeMessage::Sort)),
+            None => Err(TypeError::new(TypeMessage::Sort)),
         }
     }
 
diff --git a/dhall/src/tests.rs b/dhall/src/tests.rs
index d86574a..7795d17 100644
--- a/dhall/src/tests.rs
+++ b/dhall/src/tests.rs
@@ -158,12 +158,12 @@ pub fn run_test(test: Test<'_>) -> Result<()> {
             parse_file_str(&file_path)?.resolve().unwrap_err();
         }
         TypeInferenceSuccess(expr_file_path, expected_file_path) => {
-            // let expr =
-            //     parse_file_str(&expr_file_path)?.resolve()?.typecheck()?;
-            // let ty = expr.get_type()?.to_expr();
-            let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
-            let tyexpr = crate::semantics::nze::nzexpr::typecheck(expr)?;
-            let ty = tyexpr.get_type()?.to_expr();
+            let expr =
+                parse_file_str(&expr_file_path)?.resolve()?.typecheck()?;
+            let ty = expr.get_type()?.to_expr();
+            // let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
+            // let tyexpr = crate::semantics::nze::nzexpr::typecheck(expr)?;
+            // let ty = tyexpr.get_type()?.to_expr();
             let expected = parse_file_str(&expected_file_path)?.to_expr();
             assert_eq_display!(ty, expected);
         }
@@ -206,15 +206,15 @@ pub fn run_test(test: Test<'_>) -> Result<()> {
             }
         }
         Normalization(expr_file_path, expected_file_path) => {
-            // let expr = parse_file_str(&expr_file_path)?
-            //     .resolve()?
-            //     .typecheck()?
-            //     .normalize()
-            //     .to_expr();
-            let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
-            let expr = crate::semantics::nze::nzexpr::typecheck(expr)?
+            let expr = parse_file_str(&expr_file_path)?
+                .resolve()?
+                .typecheck()?
                 .normalize()
                 .to_expr();
+            // let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
+            // let expr = crate::semantics::nze::nzexpr::typecheck(expr)?
+            //     .normalize()
+            //     .to_expr();
             let expected = parse_file_str(&expected_file_path)?.to_expr();
 
             assert_eq_display!(expr, expected);
-- 
cgit v1.2.3


From 3182c121815857c0b2b3c057f1d2944c51332cdc Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 21 Jan 2020 18:51:00 +0000
Subject: Prepare Value for reverse variables

I thought it would work ><. It's a bit too early
---
 dhall/src/semantics/core/context.rs | 10 ++++++++--
 dhall/src/semantics/core/value.rs   | 40 ++++++++++++++++++++++++-------------
 dhall/src/semantics/core/visitor.rs |  2 +-
 dhall/src/semantics/nze/mod.rs      |  2 +-
 dhall/src/semantics/nze/nzexpr.rs   | 14 ++++++++++++-
 5 files changed, 49 insertions(+), 19 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index 8c64c26..7972a20 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -2,6 +2,7 @@ use crate::error::TypeError;
 use crate::semantics::core::value::Value;
 use crate::semantics::core::value::ValueKind;
 use crate::semantics::core::var::{AlphaVar, Binder};
+use crate::semantics::nze::NzVar;
 use crate::syntax::{Label, V};
 
 #[derive(Debug, Clone)]
@@ -42,7 +43,6 @@ impl TyCtx {
         let mut var = var.clone();
         let mut shift_delta: isize = 0;
         let mut rev_ctx = self.ctx.iter().rev().map(|(b, i)| (b.to_label(), i));
-
         let found_item = loop {
             if let Some((label, item)) = rev_ctx.next() {
                 var = match var.over_binder(&label) {
@@ -57,10 +57,16 @@ impl TyCtx {
                 return None;
             }
         };
+        let var_idx = rev_ctx
+            .filter(|(_, i)| match i {
+                CtxItem::Kept(_) => true,
+                CtxItem::Replaced(_) => false,
+            })
+            .count();
 
         let v = match found_item {
             CtxItem::Kept(t) => Value::from_kind_and_type(
-                ValueKind::Var(AlphaVar::default()),
+                ValueKind::Var(AlphaVar::default(), NzVar::new(var_idx)),
                 t.clone(),
             ),
             CtxItem::Replaced(v) => v.clone(),
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index dc6a116..a7c207d 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -4,6 +4,7 @@ use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::var::{AlphaVar, Binder};
+use crate::semantics::nze::{NzVar, QuoteEnv};
 use crate::semantics::phase::normalize::{apply_any, normalize_whnf};
 use crate::semantics::phase::typecheck::{builtin_to_value, const_to_value};
 use crate::semantics::phase::{
@@ -60,7 +61,7 @@ pub(crate) enum ValueKind<Value> {
     // Invariant: in whnf, the evaluation must not be able to progress further.
     AppliedBuiltin(Builtin, Vec<Value>),
 
-    Var(AlphaVar),
+    Var(AlphaVar, NzVar),
     Const(Const),
     BoolLit(bool),
     NaturalLit(Natural),
@@ -167,7 +168,7 @@ impl Value {
             self.normalize_nf();
         }
 
-        self.to_tyexpr().to_expr(opts)
+        self.to_tyexpr(QuoteEnv::new()).to_expr(opts)
     }
     pub(crate) fn to_whnf_ignore_type(&self) -> ValueKind<Value> {
         self.as_whnf().clone()
@@ -257,7 +258,7 @@ impl Value {
         match &*self.as_kind() {
             // If the var matches, we can just reuse the provided value instead of copying it.
             // We also check that the types match, if in debug mode.
-            ValueKind::Var(v) if v == var => {
+            ValueKind::Var(v, _) if v == var => {
                 if let Ok(self_ty) = self.get_type() {
                     val.check_type(&self_ty.subst_shift(var, val));
                 }
@@ -288,18 +289,27 @@ impl Value {
     //     }
     // }
 
-    pub fn to_tyexpr(&self) -> TyExpr {
+    pub fn to_tyexpr(&self, qenv: QuoteEnv) -> TyExpr {
         let self_kind = self.as_kind();
         let self_ty = self.as_internal().ty.clone();
         let self_span = self.as_internal().span.clone();
-        if let ValueKind::Var(v) = &*self_kind {
-            return TyExpr::new(TyExprKind::Var(*v), self_ty, self_span);
+        if let ValueKind::Var(v, _w) = &*self_kind {
+            return TyExpr::new(
+                // TODO: Only works when we don't normalize under lambdas
+                // TyExprKind::Var(qenv.lookup(w)),
+                TyExprKind::Var(*v),
+                self_ty,
+                self_span,
+            );
         }
 
         // TODO: properly recover intermediate types; `None` is a time-bomb here.
-        let self_kind = self_kind.map_ref(|v| v.to_tyexpr());
+        let self_kind = self_kind.map_ref_with_special_handling_of_binders(
+            |v| v.to_tyexpr(qenv),
+            |_, _, v| v.to_tyexpr(qenv.insert()),
+        );
         let expr = match self_kind {
-            ValueKind::Var(_) => unreachable!(),
+            ValueKind::Var(..) => unreachable!(),
             ValueKind::Lam(x, t, e) => ExprKind::Lam(x.to_label(), t, e),
             ValueKind::Pi(x, t, e) => ExprKind::Pi(x.to_label(), t, e),
             ValueKind::AppliedBuiltin(b, args) => {
@@ -320,13 +330,13 @@ impl Value {
             ValueKind::IntegerLit(n) => ExprKind::IntegerLit(n),
             ValueKind::DoubleLit(n) => ExprKind::DoubleLit(n),
             ValueKind::EmptyOptionalLit(n) => ExprKind::App(
-                builtin_to_value(Builtin::OptionalNone).to_tyexpr(),
+                builtin_to_value(Builtin::OptionalNone).to_tyexpr(qenv),
                 n,
             ),
             ValueKind::NEOptionalLit(n) => ExprKind::SomeLit(n),
             ValueKind::EmptyListLit(n) => ExprKind::EmptyListLit(TyExpr::new(
                 TyExprKind::Expr(ExprKind::App(
-                    builtin_to_value(Builtin::List).to_tyexpr(),
+                    builtin_to_value(Builtin::List).to_tyexpr(qenv),
                     n,
                 )),
                 Some(const_to_value(Const::Type)),
@@ -470,7 +480,7 @@ impl ValueKind<Value> {
 
     pub(crate) fn normalize_mut(&mut self) {
         match self {
-            ValueKind::Var(_)
+            ValueKind::Var(..)
             | ValueKind::Const(_)
             | ValueKind::BoolLit(_)
             | ValueKind::NaturalLit(_)
@@ -545,7 +555,7 @@ impl ValueKind<Value> {
 
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
         Some(match self {
-            ValueKind::Var(v) => ValueKind::Var(v.shift(delta, var)?),
+            ValueKind::Var(v, w) => ValueKind::Var(v.shift(delta, var)?, *w),
             _ => self.traverse_ref_with_special_handling_of_binders(
                 |x| Ok(x.shift(delta, var)?),
                 |_, _, x| Ok(x.shift(delta, &var.under_binder())?),
@@ -554,8 +564,10 @@ impl ValueKind<Value> {
     }
     fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
         match self {
-            ValueKind::Var(v) if v == var => val.to_whnf_ignore_type(),
-            ValueKind::Var(v) => ValueKind::Var(v.shift(-1, var).unwrap()),
+            ValueKind::Var(v, _) if v == var => val.to_whnf_ignore_type(),
+            ValueKind::Var(v, w) => {
+                ValueKind::Var(v.shift(-1, var).unwrap(), *w)
+            }
             _ => self.map_ref_with_special_handling_of_binders(
                 |x| x.subst_shift(var, val),
                 |_, _, x| {
diff --git a/dhall/src/semantics/core/visitor.rs b/dhall/src/semantics/core/visitor.rs
index a449f6c..5a04747 100644
--- a/dhall/src/semantics/core/visitor.rs
+++ b/dhall/src/semantics/core/visitor.rs
@@ -81,7 +81,7 @@ where
             Pi(l.clone(), t, e)
         }
         AppliedBuiltin(b, xs) => AppliedBuiltin(*b, v.visit_vec(xs)?),
-        Var(v) => Var(v.clone()),
+        Var(v, w) => Var(v.clone(), *w),
         Const(k) => Const(*k),
         BoolLit(b) => BoolLit(*b),
         NaturalLit(n) => NaturalLit(*n),
diff --git a/dhall/src/semantics/nze/mod.rs b/dhall/src/semantics/nze/mod.rs
index ef8918f..213404c 100644
--- a/dhall/src/semantics/nze/mod.rs
+++ b/dhall/src/semantics/nze/mod.rs
@@ -1,2 +1,2 @@
 pub mod nzexpr;
-// pub(crate) use nzexpr::*;
+pub(crate) use nzexpr::*;
diff --git a/dhall/src/semantics/nze/nzexpr.rs b/dhall/src/semantics/nze/nzexpr.rs
index 3a5a1f9..1256ea0 100644
--- a/dhall/src/semantics/nze/nzexpr.rs
+++ b/dhall/src/semantics/nze/nzexpr.rs
@@ -82,10 +82,16 @@ pub(crate) struct QuoteEnv {
 }
 
 // Reverse-debruijn index: counts number of binders from the bottom of the stack.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Eq)]
 pub(crate) struct NzVar {
     idx: usize,
 }
+// TODO: temporary hopefully
+impl std::cmp::PartialEq for NzVar {
+    fn eq(&self, _other: &Self) -> bool {
+        true
+    }
+}
 
 impl TyEnv {
     pub fn new() -> Self {
@@ -219,6 +225,12 @@ impl QuoteEnv {
     }
 }
 
+impl NzVar {
+    pub fn new(idx: usize) -> Self {
+        NzVar { idx }
+    }
+}
+
 impl TyExpr {
     pub fn new(kind: TyExprKind, ty: Option<Type>) -> Self {
         TyExpr {
-- 
cgit v1.2.3


From 9e7cc77b6a25569b61340f39a2058e23cdc4a437 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 23 Jan 2020 22:22:01 +0000
Subject: Implement basic env-based normalization for Value-based TyExpr

---
 dhall/src/semantics/core/value.rs      | 267 ++++++++++++++++++++-------------
 dhall/src/semantics/core/visitor.rs    |  18 +++
 dhall/src/semantics/nze/nzexpr.rs      |   2 +
 dhall/src/semantics/phase/normalize.rs |  85 ++++++++++-
 dhall/src/semantics/tck/tyexpr.rs      |   8 +
 dhall/src/tests.rs                     |  14 +-
 6 files changed, 283 insertions(+), 111 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index a7c207d..8beed24 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -5,7 +5,7 @@ use std::rc::Rc;
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::var::{AlphaVar, Binder};
 use crate::semantics::nze::{NzVar, QuoteEnv};
-use crate::semantics::phase::normalize::{apply_any, normalize_whnf};
+use crate::semantics::phase::normalize::{apply_any, normalize_whnf, NzEnv};
 use crate::semantics::phase::typecheck::{builtin_to_value, const_to_value};
 use crate::semantics::phase::{
     Normalized, NormalizedExpr, ToExprOptions, Typed,
@@ -53,11 +53,27 @@ pub(crate) enum Form {
     NF,
 }
 
+#[derive(Debug, Clone)]
+pub(crate) struct Closure {
+    env: NzEnv,
+    body: TyExpr,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum ValueKind<Value> {
     /// Closures
     Lam(Binder, Value, Value),
     Pi(Binder, Value, Value),
+    LamClosure {
+        binder: Binder,
+        annot: Value,
+        closure: Closure,
+    },
+    PiClosure {
+        binder: Binder,
+        annot: Value,
+        closure: Closure,
+    },
     // Invariant: in whnf, the evaluation must not be able to progress further.
     AppliedBuiltin(Builtin, Vec<Value>),
 
@@ -267,128 +283,136 @@ impl Value {
             _ => self.as_internal().subst_shift(var, val).into_value(),
         }
     }
-    // pub(crate) fn subst_ctx(&self, ctx: &TyCtx) -> Self {
-    //     match &*self.as_kind() {
-    //         ValueKind::Var(var) => match ctx.lookup_alpha(var) {
-    //             Some(val) => val,
-    //             None => unreachable!("Internal type error"),
-    //         },
-    //         kind => {
-    //             let kind = kind.map_ref_with_special_handling_of_binders(
-    //                 |x| x.subst_ctx(ctx),
-    //                 |b, t, x| x.subst_ctx(&ctx.insert_type(b, t.clone())),
-    //             );
-    //             ValueInternal {
-    //                 form: Unevaled,
-    //                 kind,
-    //                 ty: self.as_internal().ty.clone(),
-    //                 span: self.as_internal().span.clone(),
-    //             }
-    //             .into_value()
-    //         }
-    //     }
-    // }
 
     pub fn to_tyexpr(&self, qenv: QuoteEnv) -> TyExpr {
-        let self_kind = self.as_kind();
-        let self_ty = self.as_internal().ty.clone();
-        let self_span = self.as_internal().span.clone();
-        if let ValueKind::Var(v, _w) = &*self_kind {
-            return TyExpr::new(
+        let tye = match &*self.as_kind() {
+            ValueKind::Var(v, _w) => {
+                TyExprKind::Var(*v)
                 // TODO: Only works when we don't normalize under lambdas
-                // TyExprKind::Var(qenv.lookup(w)),
-                TyExprKind::Var(*v),
-                self_ty,
-                self_span,
-            );
-        }
-
-        // TODO: properly recover intermediate types; `None` is a time-bomb here.
-        let self_kind = self_kind.map_ref_with_special_handling_of_binders(
-            |v| v.to_tyexpr(qenv),
-            |_, _, v| v.to_tyexpr(qenv.insert()),
-        );
-        let expr = match self_kind {
-            ValueKind::Var(..) => unreachable!(),
-            ValueKind::Lam(x, t, e) => ExprKind::Lam(x.to_label(), t, e),
-            ValueKind::Pi(x, t, e) => ExprKind::Pi(x.to_label(), t, e),
-            ValueKind::AppliedBuiltin(b, args) => {
-                args.into_iter().fold(ExprKind::Builtin(b), |acc, v| {
-                    ExprKind::App(
-                        TyExpr::new(
-                            TyExprKind::Expr(acc),
-                            None, // TODO
-                            Span::Artificial,
-                        ),
-                        v,
-                    )
-                })
+                // TyExprKind::Var(qenv.lookup(w))
             }
-            ValueKind::Const(c) => ExprKind::Const(c),
-            ValueKind::BoolLit(b) => ExprKind::BoolLit(b),
-            ValueKind::NaturalLit(n) => ExprKind::NaturalLit(n),
-            ValueKind::IntegerLit(n) => ExprKind::IntegerLit(n),
-            ValueKind::DoubleLit(n) => ExprKind::DoubleLit(n),
-            ValueKind::EmptyOptionalLit(n) => ExprKind::App(
-                builtin_to_value(Builtin::OptionalNone).to_tyexpr(qenv),
-                n,
-            ),
-            ValueKind::NEOptionalLit(n) => ExprKind::SomeLit(n),
-            ValueKind::EmptyListLit(n) => ExprKind::EmptyListLit(TyExpr::new(
-                TyExprKind::Expr(ExprKind::App(
-                    builtin_to_value(Builtin::List).to_tyexpr(qenv),
-                    n,
-                )),
-                Some(const_to_value(Const::Type)),
-                Span::Artificial,
+            ValueKind::LamClosure {
+                binder,
+                annot,
+                closure,
+            } => TyExprKind::Expr(ExprKind::Lam(
+                binder.to_label(),
+                annot.to_tyexpr(qenv),
+                closure.apply_ty(annot.clone()).to_tyexpr(qenv.insert()),
             )),
-            ValueKind::NEListLit(elts) => ExprKind::NEListLit(elts),
-            ValueKind::RecordLit(kvs) => {
-                ExprKind::RecordLit(kvs.into_iter().collect())
-            }
-            ValueKind::RecordType(kts) => {
-                ExprKind::RecordType(kts.into_iter().collect())
-            }
-            ValueKind::UnionType(kts) => {
-                ExprKind::UnionType(kts.into_iter().collect())
-            }
-            ValueKind::UnionConstructor(l, kts, t) => ExprKind::Field(
-                TyExpr::new(
-                    TyExprKind::Expr(ExprKind::UnionType(
-                        kts.into_iter().collect(),
-                    )),
-                    Some(t),
-                    Span::Artificial,
-                ),
-                l,
-            ),
-            ValueKind::UnionLit(l, v, kts, uniont, ctort) => ExprKind::App(
-                TyExpr::new(
-                    TyExprKind::Expr(ExprKind::Field(
+            ValueKind::PiClosure {
+                binder,
+                annot,
+                closure,
+            } => TyExprKind::Expr(ExprKind::Pi(
+                binder.to_label(),
+                annot.to_tyexpr(qenv),
+                closure.apply_ty(annot.clone()).to_tyexpr(qenv.insert()),
+            )),
+            self_kind => {
+                // TODO: properly recover intermediate types; `None` is a time-bomb here.
+                let self_kind = self_kind
+                    .map_ref_with_special_handling_of_binders(
+                        |v| v.to_tyexpr(qenv),
+                        |_, _, v| v.to_tyexpr(qenv.insert()),
+                    );
+                let expr = match self_kind {
+                    ValueKind::Var(..)
+                    | ValueKind::LamClosure { .. }
+                    | ValueKind::PiClosure { .. } => unreachable!(),
+                    ValueKind::Lam(x, t, e) => {
+                        ExprKind::Lam(x.to_label(), t, e)
+                    }
+                    ValueKind::Pi(x, t, e) => ExprKind::Pi(x.to_label(), t, e),
+                    ValueKind::AppliedBuiltin(b, args) => {
+                        args.into_iter().fold(ExprKind::Builtin(b), |acc, v| {
+                            ExprKind::App(
+                                TyExpr::new(
+                                    TyExprKind::Expr(acc),
+                                    None, // TODO
+                                    Span::Artificial,
+                                ),
+                                v,
+                            )
+                        })
+                    }
+                    ValueKind::Const(c) => ExprKind::Const(c),
+                    ValueKind::BoolLit(b) => ExprKind::BoolLit(b),
+                    ValueKind::NaturalLit(n) => ExprKind::NaturalLit(n),
+                    ValueKind::IntegerLit(n) => ExprKind::IntegerLit(n),
+                    ValueKind::DoubleLit(n) => ExprKind::DoubleLit(n),
+                    ValueKind::EmptyOptionalLit(n) => ExprKind::App(
+                        builtin_to_value(Builtin::OptionalNone).to_tyexpr(qenv),
+                        n,
+                    ),
+                    ValueKind::NEOptionalLit(n) => ExprKind::SomeLit(n),
+                    ValueKind::EmptyListLit(n) => {
+                        ExprKind::EmptyListLit(TyExpr::new(
+                            TyExprKind::Expr(ExprKind::App(
+                                builtin_to_value(Builtin::List).to_tyexpr(qenv),
+                                n,
+                            )),
+                            Some(const_to_value(Const::Type)),
+                            Span::Artificial,
+                        ))
+                    }
+                    ValueKind::NEListLit(elts) => ExprKind::NEListLit(elts),
+                    ValueKind::RecordLit(kvs) => {
+                        ExprKind::RecordLit(kvs.into_iter().collect())
+                    }
+                    ValueKind::RecordType(kts) => {
+                        ExprKind::RecordType(kts.into_iter().collect())
+                    }
+                    ValueKind::UnionType(kts) => {
+                        ExprKind::UnionType(kts.into_iter().collect())
+                    }
+                    ValueKind::UnionConstructor(l, kts, t) => ExprKind::Field(
                         TyExpr::new(
                             TyExprKind::Expr(ExprKind::UnionType(
                                 kts.into_iter().collect(),
                             )),
-                            Some(uniont),
+                            Some(t),
                             Span::Artificial,
                         ),
                         l,
-                    )),
-                    Some(ctort),
-                    Span::Artificial,
-                ),
-                v,
-            ),
-            ValueKind::TextLit(elts) => {
-                ExprKind::TextLit(elts.into_iter().collect())
-            }
-            ValueKind::Equivalence(x, y) => {
-                ExprKind::BinOp(BinOp::Equivalence, x, y)
+                    ),
+                    ValueKind::UnionLit(l, v, kts, uniont, ctort) => {
+                        ExprKind::App(
+                            TyExpr::new(
+                                TyExprKind::Expr(ExprKind::Field(
+                                    TyExpr::new(
+                                        TyExprKind::Expr(ExprKind::UnionType(
+                                            kts.into_iter().collect(),
+                                        )),
+                                        Some(uniont),
+                                        Span::Artificial,
+                                    ),
+                                    l,
+                                )),
+                                Some(ctort),
+                                Span::Artificial,
+                            ),
+                            v,
+                        )
+                    }
+                    ValueKind::TextLit(elts) => {
+                        ExprKind::TextLit(elts.into_iter().collect())
+                    }
+                    ValueKind::Equivalence(x, y) => {
+                        ExprKind::BinOp(BinOp::Equivalence, x, y)
+                    }
+                    ValueKind::PartialExpr(e) => e,
+                };
+                TyExprKind::Expr(expr)
             }
-            ValueKind::PartialExpr(e) => e,
         };
 
-        TyExpr::new(TyExprKind::Expr(expr), self_ty, self_span)
+        let self_ty = self.as_internal().ty.clone();
+        let self_span = self.as_internal().span.clone();
+        TyExpr::new(tye, self_ty, self_span)
+    }
+    pub fn to_tyexpr_noenv(&self) -> TyExpr {
+        self.to_tyexpr(QuoteEnv::new())
     }
 }
 
@@ -502,6 +526,10 @@ impl ValueKind<Value> {
                 t.normalize_mut();
                 e.normalize_mut();
             }
+            ValueKind::LamClosure { annot, .. }
+            | ValueKind::PiClosure { annot, .. } => {
+                annot.normalize_mut();
+            }
             ValueKind::AppliedBuiltin(_, args) => {
                 for x in args.iter_mut() {
                     x.normalize_mut();
@@ -620,6 +648,21 @@ impl<V> ValueKind<V> {
     }
 }
 
+impl Closure {
+    pub fn new(env: &NzEnv, body: TyExpr) -> Self {
+        Closure {
+            env: env.clone(),
+            body: body,
+        }
+    }
+    pub fn apply(&self, val: Value) -> Value {
+        self.body.normalize_whnf(&self.env.insert_value(val))
+    }
+    pub fn apply_ty(&self, ty: Value) -> Value {
+        self.body.normalize_whnf(&self.env.insert_type(ty))
+    }
+}
+
 // TODO: use Rc comparison to shortcut on identical pointers
 impl std::cmp::PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {
@@ -628,6 +671,14 @@ impl std::cmp::PartialEq for Value {
 }
 impl std::cmp::Eq for Value {}
 
+// TODO: panics
+impl std::cmp::PartialEq for Closure {
+    fn eq(&self, _other: &Self) -> bool {
+        panic!("comparing closures for equality seems like a bad idea")
+    }
+}
+impl std::cmp::Eq for Closure {}
+
 impl std::fmt::Debug for Value {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let vint: &ValueInternal = &self.as_internal();
diff --git a/dhall/src/semantics/core/visitor.rs b/dhall/src/semantics/core/visitor.rs
index 5a04747..ee44ed7 100644
--- a/dhall/src/semantics/core/visitor.rs
+++ b/dhall/src/semantics/core/visitor.rs
@@ -80,6 +80,24 @@ where
             let (t, e) = v.visit_binder(l, t, e)?;
             Pi(l.clone(), t, e)
         }
+        LamClosure {
+            binder,
+            annot,
+            closure,
+        } => LamClosure {
+            binder: binder.clone(),
+            annot: v.visit_val(annot)?,
+            closure: closure.clone(),
+        },
+        PiClosure {
+            binder,
+            annot,
+            closure,
+        } => PiClosure {
+            binder: binder.clone(),
+            annot: v.visit_val(annot)?,
+            closure: closure.clone(),
+        },
         AppliedBuiltin(b, xs) => AppliedBuiltin(*b, v.visit_vec(xs)?),
         Var(v, w) => Var(v.clone(), *w),
         Const(k) => Const(*k),
diff --git a/dhall/src/semantics/nze/nzexpr.rs b/dhall/src/semantics/nze/nzexpr.rs
index 1256ea0..723c895 100644
--- a/dhall/src/semantics/nze/nzexpr.rs
+++ b/dhall/src/semantics/nze/nzexpr.rs
@@ -200,6 +200,7 @@ impl NzEnv {
         env
     }
     pub fn lookup_val(&self, var: &AlphaVar) -> NzExpr {
+        // TODO: use VarEnv
         let idx = self.items.len() - 1 - var.idx();
         match &self.items[idx] {
             NzEnvItem::Kept(ty) => NzExpr::new(
@@ -211,6 +212,7 @@ impl NzEnv {
     }
 }
 
+// TODO: rename to VarEnv
 impl QuoteEnv {
     pub fn new() -> Self {
         QuoteEnv { size: 0 }
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index f0a6a8c..7fd76df 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -1,9 +1,12 @@
 use std::collections::HashMap;
 use std::convert::TryInto;
 
+use crate::semantics::nze::NzVar;
 use crate::semantics::phase::typecheck::{rc, typecheck};
 use crate::semantics::phase::Normalized;
-use crate::semantics::{AlphaVar, Value, ValueKind};
+use crate::semantics::{
+    AlphaVar, Binder, Closure, TyExpr, TyExprKind, Value, ValueKind,
+};
 use crate::syntax;
 use crate::syntax::Const::Type;
 use crate::syntax::{
@@ -786,3 +789,83 @@ pub(crate) fn normalize_whnf(
         v => v,
     }
 }
+
+#[derive(Debug, Clone)]
+enum NzEnvItem {
+    // Variable is bound with given type
+    Kept(Value),
+    // Variable has been replaced by corresponding value
+    Replaced(Value),
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct NzEnv {
+    items: Vec<NzEnvItem>,
+}
+
+impl NzEnv {
+    pub fn new() -> Self {
+        NzEnv { items: Vec::new() }
+    }
+
+    pub fn insert_type(&self, t: Value) -> Self {
+        let mut env = self.clone();
+        env.items.push(NzEnvItem::Kept(t));
+        env
+    }
+    pub fn insert_value(&self, e: Value) -> Self {
+        let mut env = self.clone();
+        env.items.push(NzEnvItem::Replaced(e));
+        env
+    }
+    pub fn lookup_val(&self, var: &AlphaVar) -> Value {
+        let idx = self.items.len() - 1 - var.idx();
+        match &self.items[idx] {
+            NzEnvItem::Kept(ty) => Value::from_kind_and_type_whnf(
+                ValueKind::Var(var.clone(), NzVar::new(idx)),
+                ty.clone(),
+            ),
+            NzEnvItem::Replaced(x) => x.clone(),
+        }
+    }
+}
+
+/// Normalize a TyExpr into WHNF
+pub(crate) fn normalize_tyexpr_whnf(e: &TyExpr, env: &NzEnv) -> Value {
+    let kind = match e.kind() {
+        TyExprKind::Var(var) => return env.lookup_val(var),
+        TyExprKind::Expr(ExprKind::Lam(binder, annot, body)) => {
+            ValueKind::LamClosure {
+                binder: Binder::new(binder.clone()),
+                annot: annot.normalize_whnf(env),
+                closure: Closure::new(env, body.clone()),
+            }
+        }
+        TyExprKind::Expr(ExprKind::Pi(binder, annot, body)) => {
+            ValueKind::PiClosure {
+                binder: Binder::new(binder.clone()),
+                annot: annot.normalize_whnf(env),
+                closure: Closure::new(env, body.clone()),
+            }
+        }
+        TyExprKind::Expr(e) => {
+            let e = e.map_ref(|tye| tye.normalize_whnf(env));
+            match e {
+                ExprKind::App(f, arg) => {
+                    let f_borrow = f.as_whnf();
+                    match &*f_borrow {
+                        ValueKind::LamClosure { closure, .. } => {
+                            return closure.apply(arg)
+                        }
+                        _ => {
+                            drop(f_borrow);
+                            ValueKind::PartialExpr(ExprKind::App(f, arg))
+                        }
+                    }
+                }
+                _ => ValueKind::PartialExpr(e),
+            }
+        }
+    };
+    Value::from_kind_and_type_whnf(kind, e.get_type().unwrap())
+}
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index 983f3f8..c8be3a3 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -1,6 +1,7 @@
 #![allow(dead_code)]
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::var::AlphaVar;
+use crate::semantics::phase::normalize::{normalize_tyexpr_whnf, NzEnv};
 use crate::semantics::phase::typecheck::rc;
 use crate::semantics::phase::Normalized;
 use crate::semantics::phase::{NormalizedExpr, ToExprOptions};
@@ -51,6 +52,13 @@ impl TyExpr {
     pub fn to_value(&self) -> Value {
         todo!()
     }
+
+    pub fn normalize_whnf(&self, env: &NzEnv) -> Value {
+        normalize_tyexpr_whnf(self, env)
+    }
+    pub fn normalize_whnf_noenv(&self) -> Value {
+        normalize_tyexpr_whnf(self, &NzEnv::new())
+    }
 }
 
 fn tyexpr_to_expr<'a>(
diff --git a/dhall/src/tests.rs b/dhall/src/tests.rs
index 7795d17..4928c51 100644
--- a/dhall/src/tests.rs
+++ b/dhall/src/tests.rs
@@ -206,11 +206,21 @@ pub fn run_test(test: Test<'_>) -> Result<()> {
             }
         }
         Normalization(expr_file_path, expected_file_path) => {
+            // let expr = parse_file_str(&expr_file_path)?
+            //     .resolve()?
+            //     .typecheck()?
+            //     .normalize()
+            //     .to_expr();
             let expr = parse_file_str(&expr_file_path)?
                 .resolve()?
                 .typecheck()?
-                .normalize()
-                .to_expr();
+                .to_value()
+                .to_tyexpr_noenv()
+                .normalize_whnf_noenv()
+                .to_expr(crate::semantics::phase::ToExprOptions {
+                    alpha: false,
+                    normalize: true,
+                });
             // let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
             // let expr = crate::semantics::nze::nzexpr::typecheck(expr)?
             //     .normalize()
-- 
cgit v1.2.3


From fccccac6463cb3ca91206d5c41bbf51fc2ec4e0f Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 24 Jan 2020 16:01:08 +0000
Subject: Reuse normalize_one_layer in new eval flow

---
 dhall/src/semantics/phase/normalize.rs | 68 ++++++++++++++++++++--------------
 1 file changed, 41 insertions(+), 27 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index 7fd76df..75d61d5 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -2,7 +2,9 @@ use std::collections::HashMap;
 use std::convert::TryInto;
 
 use crate::semantics::nze::NzVar;
-use crate::semantics::phase::typecheck::{rc, typecheck};
+use crate::semantics::phase::typecheck::{
+    builtin_to_value, const_to_value, rc, typecheck,
+};
 use crate::semantics::phase::Normalized;
 use crate::semantics::{
     AlphaVar, Binder, Closure, TyExpr, TyExprKind, Value, ValueKind,
@@ -372,6 +374,9 @@ pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
         ValueKind::Lam(_, _, e) => e
             .subst_shift(&AlphaVar::default(), &a)
             .to_whnf_check_type(ty),
+        ValueKind::LamClosure { closure, .. } => {
+            closure.apply(a).to_whnf_check_type(ty)
+        }
         ValueKind::AppliedBuiltin(b, args) => {
             use std::iter::once;
             let args = args.iter().cloned().chain(once(a.clone())).collect();
@@ -597,8 +602,8 @@ pub(crate) fn normalize_one_layer(
 ) -> ValueKind<Value> {
     use ValueKind::{
         BoolLit, DoubleLit, EmptyOptionalLit, IntegerLit, NEListLit,
-        NEOptionalLit, NaturalLit, RecordLit, TextLit, UnionConstructor,
-        UnionLit, UnionType,
+        NEOptionalLit, NaturalLit, RecordLit, RecordType, TextLit,
+        UnionConstructor, UnionLit, UnionType,
     };
 
     let ret = match expr {
@@ -611,15 +616,12 @@ pub(crate) fn normalize_one_layer(
         | ExprKind::Pi(_, _, _)
         | ExprKind::Let(_, _, _, _)
         | ExprKind::Embed(_)
-        | ExprKind::Const(_)
-        | ExprKind::Builtin(_)
         | ExprKind::Var(_)
-        | ExprKind::Annot(_, _)
-        | ExprKind::EmptyListLit(_)
-        | ExprKind::RecordType(_)
-        | ExprKind::UnionType(_) => {
+        | ExprKind::Annot(_, _) => {
             unreachable!("This case should have been handled in typecheck")
         }
+        ExprKind::Const(c) => Ret::Value(const_to_value(c)),
+        ExprKind::Builtin(b) => Ret::Value(builtin_to_value(b)),
         ExprKind::Assert(_) => Ret::Expr(expr),
         ExprKind::App(v, a) => Ret::Value(v.app(a)),
         ExprKind::BoolLit(b) => Ret::ValueKind(BoolLit(b)),
@@ -627,12 +629,29 @@ pub(crate) fn normalize_one_layer(
         ExprKind::IntegerLit(n) => Ret::ValueKind(IntegerLit(n)),
         ExprKind::DoubleLit(n) => Ret::ValueKind(DoubleLit(n)),
         ExprKind::SomeLit(e) => Ret::ValueKind(NEOptionalLit(e)),
+        ExprKind::EmptyListLit(t) => {
+            let arg = match &*t.as_whnf() {
+                ValueKind::AppliedBuiltin(syntax::Builtin::List, args)
+                    if args.len() == 1 =>
+                {
+                    args[0].clone()
+                }
+                _ => panic!("internal type error"),
+            };
+            Ret::ValueKind(ValueKind::EmptyListLit(arg))
+        }
         ExprKind::NEListLit(elts) => {
             Ret::ValueKind(NEListLit(elts.into_iter().collect()))
         }
         ExprKind::RecordLit(kvs) => {
             Ret::ValueKind(RecordLit(kvs.into_iter().collect()))
         }
+        ExprKind::RecordType(kvs) => {
+            Ret::ValueKind(RecordType(kvs.into_iter().collect()))
+        }
+        ExprKind::UnionType(kvs) => {
+            Ret::ValueKind(UnionType(kvs.into_iter().collect()))
+        }
         ExprKind::TextLit(elts) => {
             use InterpolatedTextContents::Expr;
             let elts: Vec<_> = squash_textlit(elts.into_iter());
@@ -665,6 +684,13 @@ pub(crate) fn normalize_one_layer(
                 }
             }
         }
+        // ExprKind::BinOp(RecursiveRecordTypeMerge, l, r) => { }
+        // ExprKind::BinOp(Equivalence, l, r) => {
+        //     RetWhole(Value::from_kind_and_type(
+        //         ValueKind::Equivalence(l.clone(), r.clone()),
+        //         Value::from_const(Type),
+        //     ))
+        // }
         ExprKind::BinOp(o, ref x, ref y) => match apply_binop(o, x, y, ty) {
             Some(ret) => ret,
             None => Ret::Expr(expr),
@@ -831,8 +857,9 @@ impl NzEnv {
 }
 
 /// Normalize a TyExpr into WHNF
-pub(crate) fn normalize_tyexpr_whnf(e: &TyExpr, env: &NzEnv) -> Value {
-    let kind = match e.kind() {
+pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> Value {
+    let ty = tye.get_type().unwrap();
+    let kind = match tye.kind() {
         TyExprKind::Var(var) => return env.lookup_val(var),
         TyExprKind::Expr(ExprKind::Lam(binder, annot, body)) => {
             ValueKind::LamClosure {
@@ -850,22 +877,9 @@ pub(crate) fn normalize_tyexpr_whnf(e: &TyExpr, env: &NzEnv) -> Value {
         }
         TyExprKind::Expr(e) => {
             let e = e.map_ref(|tye| tye.normalize_whnf(env));
-            match e {
-                ExprKind::App(f, arg) => {
-                    let f_borrow = f.as_whnf();
-                    match &*f_borrow {
-                        ValueKind::LamClosure { closure, .. } => {
-                            return closure.apply(arg)
-                        }
-                        _ => {
-                            drop(f_borrow);
-                            ValueKind::PartialExpr(ExprKind::App(f, arg))
-                        }
-                    }
-                }
-                _ => ValueKind::PartialExpr(e),
-            }
+            normalize_one_layer(e, &ty)
         }
     };
-    Value::from_kind_and_type_whnf(kind, e.get_type().unwrap())
+
+    Value::from_kind_and_type_whnf(kind, ty)
 }
-- 
cgit v1.2.3


From bd1eb36503aa6e03532fefcfd0c4f27eb62c99d2 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 24 Jan 2020 16:29:25 +0000
Subject: Restore all types in Value::to_tyexpr

---
 dhall/src/semantics/core/value.rs      | 119 ++++++++++++++++++++-------------
 dhall/src/semantics/core/visitor.rs    |  16 +++--
 dhall/src/semantics/phase/normalize.rs |  18 +++--
 dhall/src/semantics/phase/typecheck.rs |  12 ++--
 4 files changed, 101 insertions(+), 64 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 8beed24..3798053 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -75,7 +75,8 @@ pub(crate) enum ValueKind<Value> {
         closure: Closure,
     },
     // Invariant: in whnf, the evaluation must not be able to progress further.
-    AppliedBuiltin(Builtin, Vec<Value>),
+    // Keep types around to be able to recover the types of partial applications.
+    AppliedBuiltin(Builtin, Vec<Value>, Vec<Value>),
 
     Var(AlphaVar, NzVar),
     Const(Const),
@@ -92,9 +93,9 @@ pub(crate) enum ValueKind<Value> {
     RecordLit(HashMap<Label, Value>),
     UnionType(HashMap<Label, Option<Value>>),
     // Also keep the type of the uniontype around
-    UnionConstructor(Label, HashMap<Label, Option<Value>>, Type),
+    UnionConstructor(Label, HashMap<Label, Option<Value>>, Value),
     // Also keep the type of the uniontype and the constructor around
-    UnionLit(Label, Value, HashMap<Label, Option<Value>>, Type, Type),
+    UnionLit(Label, Value, HashMap<Label, Option<Value>>, Value, Value),
     // Invariant: in whnf, this must not contain interpolations that are themselves TextLits, and
     // contiguous text values must be merged.
     TextLit(Vec<InterpolatedTextContents<Value>>),
@@ -309,8 +310,68 @@ impl Value {
                 annot.to_tyexpr(qenv),
                 closure.apply_ty(annot.clone()).to_tyexpr(qenv.insert()),
             )),
+            ValueKind::AppliedBuiltin(b, args, types) => {
+                TyExprKind::Expr(args.into_iter().zip(types.into_iter()).fold(
+                    ExprKind::Builtin(*b),
+                    |acc, (v, ty)| {
+                        ExprKind::App(
+                            TyExpr::new(
+                                TyExprKind::Expr(acc),
+                                Some(ty.clone()),
+                                Span::Artificial,
+                            ),
+                            v.to_tyexpr(qenv),
+                        )
+                    },
+                ))
+            }
+            ValueKind::UnionConstructor(l, kts, t) => {
+                TyExprKind::Expr(ExprKind::Field(
+                    TyExpr::new(
+                        TyExprKind::Expr(ExprKind::UnionType(
+                            kts.into_iter()
+                                .map(|(k, v)| {
+                                    (
+                                        k.clone(),
+                                        v.as_ref().map(|v| v.to_tyexpr(qenv)),
+                                    )
+                                })
+                                .collect(),
+                        )),
+                        Some(t.clone()),
+                        Span::Artificial,
+                    ),
+                    l.clone(),
+                ))
+            }
+            ValueKind::UnionLit(l, v, kts, uniont, ctort) => {
+                TyExprKind::Expr(ExprKind::App(
+                    TyExpr::new(
+                        TyExprKind::Expr(ExprKind::Field(
+                            TyExpr::new(
+                                TyExprKind::Expr(ExprKind::UnionType(
+                                    kts.into_iter()
+                                        .map(|(k, v)| {
+                                            (
+                                                k.clone(),
+                                                v.as_ref()
+                                                    .map(|v| v.to_tyexpr(qenv)),
+                                            )
+                                        })
+                                        .collect(),
+                                )),
+                                Some(uniont.clone()),
+                                Span::Artificial,
+                            ),
+                            l.clone(),
+                        )),
+                        Some(ctort.clone()),
+                        Span::Artificial,
+                    ),
+                    v.to_tyexpr(qenv),
+                ))
+            }
             self_kind => {
-                // TODO: properly recover intermediate types; `None` is a time-bomb here.
                 let self_kind = self_kind
                     .map_ref_with_special_handling_of_binders(
                         |v| v.to_tyexpr(qenv),
@@ -319,23 +380,14 @@ impl Value {
                 let expr = match self_kind {
                     ValueKind::Var(..)
                     | ValueKind::LamClosure { .. }
-                    | ValueKind::PiClosure { .. } => unreachable!(),
+                    | ValueKind::PiClosure { .. }
+                    | ValueKind::AppliedBuiltin(..)
+                    | ValueKind::UnionConstructor(..)
+                    | ValueKind::UnionLit(..) => unreachable!(),
                     ValueKind::Lam(x, t, e) => {
                         ExprKind::Lam(x.to_label(), t, e)
                     }
                     ValueKind::Pi(x, t, e) => ExprKind::Pi(x.to_label(), t, e),
-                    ValueKind::AppliedBuiltin(b, args) => {
-                        args.into_iter().fold(ExprKind::Builtin(b), |acc, v| {
-                            ExprKind::App(
-                                TyExpr::new(
-                                    TyExprKind::Expr(acc),
-                                    None, // TODO
-                                    Span::Artificial,
-                                ),
-                                v,
-                            )
-                        })
-                    }
                     ValueKind::Const(c) => ExprKind::Const(c),
                     ValueKind::BoolLit(b) => ExprKind::BoolLit(b),
                     ValueKind::NaturalLit(n) => ExprKind::NaturalLit(n),
@@ -366,35 +418,6 @@ impl Value {
                     ValueKind::UnionType(kts) => {
                         ExprKind::UnionType(kts.into_iter().collect())
                     }
-                    ValueKind::UnionConstructor(l, kts, t) => ExprKind::Field(
-                        TyExpr::new(
-                            TyExprKind::Expr(ExprKind::UnionType(
-                                kts.into_iter().collect(),
-                            )),
-                            Some(t),
-                            Span::Artificial,
-                        ),
-                        l,
-                    ),
-                    ValueKind::UnionLit(l, v, kts, uniont, ctort) => {
-                        ExprKind::App(
-                            TyExpr::new(
-                                TyExprKind::Expr(ExprKind::Field(
-                                    TyExpr::new(
-                                        TyExprKind::Expr(ExprKind::UnionType(
-                                            kts.into_iter().collect(),
-                                        )),
-                                        Some(uniont),
-                                        Span::Artificial,
-                                    ),
-                                    l,
-                                )),
-                                Some(ctort),
-                                Span::Artificial,
-                            ),
-                            v,
-                        )
-                    }
                     ValueKind::TextLit(elts) => {
                         ExprKind::TextLit(elts.into_iter().collect())
                     }
@@ -530,7 +553,7 @@ impl ValueKind<Value> {
             | ValueKind::PiClosure { annot, .. } => {
                 annot.normalize_mut();
             }
-            ValueKind::AppliedBuiltin(_, args) => {
+            ValueKind::AppliedBuiltin(_, args, _) => {
                 for x in args.iter_mut() {
                     x.normalize_mut();
                 }
@@ -578,7 +601,7 @@ impl ValueKind<Value> {
     }
 
     pub(crate) fn from_builtin(b: Builtin) -> ValueKind<Value> {
-        ValueKind::AppliedBuiltin(b, vec![])
+        ValueKind::AppliedBuiltin(b, vec![], vec![])
     }
 
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
diff --git a/dhall/src/semantics/core/visitor.rs b/dhall/src/semantics/core/visitor.rs
index ee44ed7..64250b0 100644
--- a/dhall/src/semantics/core/visitor.rs
+++ b/dhall/src/semantics/core/visitor.rs
@@ -98,7 +98,9 @@ where
             annot: v.visit_val(annot)?,
             closure: closure.clone(),
         },
-        AppliedBuiltin(b, xs) => AppliedBuiltin(*b, v.visit_vec(xs)?),
+        AppliedBuiltin(b, xs, types) => {
+            AppliedBuiltin(*b, v.visit_vec(xs)?, v.visit_vec(types)?)
+        }
         Var(v, w) => Var(v.clone(), *w),
         Const(k) => Const(*k),
         BoolLit(b) => BoolLit(*b),
@@ -112,15 +114,17 @@ where
         RecordType(kts) => RecordType(v.visit_map(kts)?),
         RecordLit(kvs) => RecordLit(v.visit_map(kvs)?),
         UnionType(kts) => UnionType(v.visit_optmap(kts)?),
-        UnionConstructor(l, kts, t) => {
-            UnionConstructor(l.clone(), v.visit_optmap(kts)?, t.clone())
-        }
+        UnionConstructor(l, kts, uniont) => UnionConstructor(
+            l.clone(),
+            v.visit_optmap(kts)?,
+            v.visit_val(uniont)?,
+        ),
         UnionLit(l, x, kts, uniont, ctort) => UnionLit(
             l.clone(),
             v.visit_val(x)?,
             v.visit_optmap(kts)?,
-            uniont.clone(),
-            ctort.clone(),
+            v.visit_val(uniont)?,
+            v.visit_val(ctort)?,
         ),
         TextLit(ts) => TextLit(
             ts.iter()
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index 75d61d5..8f3953d 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -71,6 +71,7 @@ pub(crate) fn apply_builtin(
     b: Builtin,
     args: Vec<Value>,
     ty: &Value,
+    types: Vec<Value>,
 ) -> ValueKind<Value> {
     use syntax::Builtin::*;
     use ValueKind::*;
@@ -364,7 +365,7 @@ pub(crate) fn apply_builtin(
             }
             v.to_whnf_check_type(ty)
         }
-        Ret::DoneAsIs => AppliedBuiltin(b, args),
+        Ret::DoneAsIs => AppliedBuiltin(b, args, types),
     }
 }
 
@@ -377,10 +378,15 @@ pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
         ValueKind::LamClosure { closure, .. } => {
             closure.apply(a).to_whnf_check_type(ty)
         }
-        ValueKind::AppliedBuiltin(b, args) => {
+        ValueKind::AppliedBuiltin(b, args, types) => {
             use std::iter::once;
             let args = args.iter().cloned().chain(once(a.clone())).collect();
-            apply_builtin(*b, args, ty)
+            let types = types
+                .iter()
+                .cloned()
+                .chain(once(f.get_type().unwrap()))
+                .collect();
+            apply_builtin(*b, args, ty, types)
         }
         ValueKind::UnionConstructor(l, kts, uniont) => ValueKind::UnionLit(
             l.clone(),
@@ -631,7 +637,7 @@ pub(crate) fn normalize_one_layer(
         ExprKind::SomeLit(e) => Ret::ValueKind(NEOptionalLit(e)),
         ExprKind::EmptyListLit(t) => {
             let arg = match &*t.as_whnf() {
-                ValueKind::AppliedBuiltin(syntax::Builtin::List, args)
+                ValueKind::AppliedBuiltin(syntax::Builtin::List, args, _)
                     if args.len() == 1 =>
                 {
                     args[0].clone()
@@ -806,7 +812,9 @@ pub(crate) fn normalize_whnf(
     ty: &Value,
 ) -> ValueKind<Value> {
     match v {
-        ValueKind::AppliedBuiltin(b, args) => apply_builtin(b, args, ty),
+        ValueKind::AppliedBuiltin(b, args, types) => {
+            apply_builtin(b, args, ty, types)
+        }
         ValueKind::PartialExpr(e) => normalize_one_layer(e, ty),
         ValueKind::TextLit(elts) => {
             ValueKind::TextLit(squash_textlit(elts.into_iter()))
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index 9e41f1e..f2d1bf2 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -421,7 +421,7 @@ fn type_last_layer(
         }
         EmptyListLit(t) => {
             let arg = match &*t.as_whnf() {
-                ValueKind::AppliedBuiltin(syntax::Builtin::List, args)
+                ValueKind::AppliedBuiltin(syntax::Builtin::List, args, _)
                     if args.len() == 1 =>
                 {
                     args[0].clone()
@@ -613,7 +613,7 @@ fn type_last_layer(
         }
         BinOp(o @ ListAppend, l, r) => {
             match &*l.get_type()?.as_whnf() {
-                ValueKind::AppliedBuiltin(List, _) => {}
+                ValueKind::AppliedBuiltin(List, _, _) => {}
                 _ => return mkerr(BinOpTypeMismatch(*o, l.clone())),
             }
 
@@ -679,9 +679,11 @@ fn type_last_layer(
             let union_borrow = union_type.as_whnf();
             let variants = match &*union_borrow {
                 ValueKind::UnionType(kts) => Cow::Borrowed(kts),
-                ValueKind::AppliedBuiltin(syntax::Builtin::Optional, args)
-                    if args.len() == 1 =>
-                {
+                ValueKind::AppliedBuiltin(
+                    syntax::Builtin::Optional,
+                    args,
+                    _,
+                ) if args.len() == 1 => {
                     let ty = &args[0];
                     let mut kts = HashMap::new();
                     kts.insert("None".into(), None);
-- 
cgit v1.2.3


From 700ff482fbff8960bc0e792fec6fd538c5428d70 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 24 Jan 2020 17:07:56 +0000
Subject: Normalize more expressions

---
 dhall/src/semantics/core/value.rs      |  6 +++++-
 dhall/src/semantics/phase/normalize.rs | 13 +++++--------
 2 files changed, 10 insertions(+), 9 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 3798053..3e3bfe1 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -10,7 +10,7 @@ use crate::semantics::phase::typecheck::{builtin_to_value, const_to_value};
 use crate::semantics::phase::{
     Normalized, NormalizedExpr, ToExprOptions, Typed,
 };
-use crate::semantics::{TyExpr, TyExprKind, Type};
+use crate::semantics::{TyExpr, TyExprKind};
 use crate::syntax::{
     BinOp, Builtin, Const, ExprKind, Integer, InterpolatedTextContents, Label,
     NaiveDouble, Natural, Span,
@@ -235,6 +235,10 @@ impl Value {
                 v.check_type(t);
                 e.subst_shift(&AlphaVar::default(), &v)
             }
+            ValueKind::PiClosure { annot, closure, .. } => {
+                v.check_type(annot);
+                closure.apply(v.clone())
+            }
             _ => unreachable!("Internal type error"),
         };
         Value::from_kind_and_type_whnf(
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index 8f3953d..ac60ce0 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -594,10 +594,14 @@ fn apply_binop<'a>(
             Ret::ValueKind(RecordLit(kvs))
         }
 
-        (RecursiveRecordTypeMerge, _, _) | (Equivalence, _, _) => {
+        (RecursiveRecordTypeMerge, _, _) => {
             unreachable!("This case should have been handled in typecheck")
         }
 
+        (Equivalence, _, _) => {
+            Ret::ValueKind(ValueKind::Equivalence(x.clone(), y.clone()))
+        }
+
         _ => return None,
     })
 }
@@ -690,13 +694,6 @@ pub(crate) fn normalize_one_layer(
                 }
             }
         }
-        // ExprKind::BinOp(RecursiveRecordTypeMerge, l, r) => { }
-        // ExprKind::BinOp(Equivalence, l, r) => {
-        //     RetWhole(Value::from_kind_and_type(
-        //         ValueKind::Equivalence(l.clone(), r.clone()),
-        //         Value::from_const(Type),
-        //     ))
-        // }
         ExprKind::BinOp(o, ref x, ref y) => match apply_binop(o, x, y, ty) {
             Some(ret) => ret,
             None => Ret::Expr(expr),
-- 
cgit v1.2.3


From ee3a5e08e005c54cb839278c95920a147a356d2d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 24 Jan 2020 17:08:05 +0000
Subject: Disable runtime type checks

---
 dhall/src/semantics/core/value.rs | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 3e3bfe1..96bb99a 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -249,12 +249,13 @@ impl Value {
 
     /// In debug mode, panic if the provided type doesn't match the value's type.
     /// Otherwise does nothing.
-    pub(crate) fn check_type(&self, ty: &Value) {
-        debug_assert_eq!(
-            Some(ty),
-            self.get_type().ok().as_ref(),
-            "Internal type error"
-        );
+    pub(crate) fn check_type(&self, _ty: &Value) {
+        // TODO: reenable
+        // debug_assert_eq!(
+        //     Some(ty),
+        //     self.get_type().ok().as_ref(),
+        //     "Internal type error"
+        // );
     }
     pub(crate) fn get_type(&self) -> Result<Value, TypeError> {
         Ok(self.as_internal().get_type()?.clone())
-- 
cgit v1.2.3


From 0d4e033c7ca301f03453210fdef345bdf8018892 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 24 Jan 2020 17:12:22 +0000
Subject: Update type-errors

---
 dhall/tests/type-errors/unit/AnnotationRecordWrongFieldName.txt       | 2 +-
 dhall/tests/type-errors/unit/AnnotationRecordWrongFieldType.txt       | 2 +-
 dhall/tests/type-errors/unit/AssertDoubleZeros.txt                    | 2 +-
 dhall/tests/type-errors/unit/AssertTriviallyFalse.txt                 | 2 +-
 dhall/tests/type-errors/unit/EquivalenceNotSameType.txt               | 2 +-
 dhall/tests/type-errors/unit/EquivalenceNotTerms.txt                  | 2 +-
 dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt  | 4 ++--
 dhall/tests/type-errors/unit/IfBranchesNotMatch.txt                   | 2 +-
 dhall/tests/type-errors/unit/IfNotBool.txt                            | 2 +-
 dhall/tests/type-errors/unit/LetWithWrongAnnotation.txt               | 2 +-
 dhall/tests/type-errors/unit/ListLiteralTypesNotMatch.txt             | 2 +-
 dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt  | 2 +-
 dhall/tests/type-errors/unit/MergeLhsNotRecord.txt                    | 2 +-
 dhall/tests/type-errors/unit/MergeRhsNotUnion.txt                     | 2 +-
 dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt            | 4 ++--
 dhall/tests/type-errors/unit/OperatorAndNotBool.txt                   | 2 +-
 dhall/tests/type-errors/unit/OperatorEqualNotBool.txt                 | 2 +-
 dhall/tests/type-errors/unit/OperatorListConcatenateLhsNotList.txt    | 2 +-
 dhall/tests/type-errors/unit/OperatorListConcatenateListsNotMatch.txt | 2 +-
 .../type-errors/unit/OperatorListConcatenateNotListsButMatch.txt      | 2 +-
 dhall/tests/type-errors/unit/OperatorListConcatenateRhsNotList.txt    | 2 +-
 dhall/tests/type-errors/unit/OperatorNotEqualNotBool.txt              | 2 +-
 dhall/tests/type-errors/unit/OperatorOrNotBool.txt                    | 2 +-
 dhall/tests/type-errors/unit/OperatorPlusNotNatural.txt               | 2 +-
 dhall/tests/type-errors/unit/OperatorTextConcatenateLhsNotText.txt    | 2 +-
 dhall/tests/type-errors/unit/OperatorTextConcatenateRhsNotText.txt    | 2 +-
 dhall/tests/type-errors/unit/OperatorTimesNotNatural.txt              | 2 +-
 dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxAbsent.txt       | 2 +-
 dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxPresent.txt      | 2 +-
 dhall/tests/type-errors/unit/RecordSelectionNotRecord.txt             | 2 +-
 dhall/tests/type-errors/unit/RecordSelectionTypeNotUnionType.txt      | 2 +-
 dhall/tests/type-errors/unit/RecordTypeValueMember.txt                | 2 +-
 dhall/tests/type-errors/unit/RecursiveRecordMergeLhsNotRecord.txt     | 2 +-
 dhall/tests/type-errors/unit/RecursiveRecordMergeOverlapping.txt      | 2 +-
 dhall/tests/type-errors/unit/RecursiveRecordMergeRhsNotRecord.txt     | 2 +-
 .../type-errors/unit/RecursiveRecordTypeMergeLhsNotRecordType.txt     | 2 +-
 dhall/tests/type-errors/unit/RecursiveRecordTypeMergeOverlapping.txt  | 2 +-
 .../type-errors/unit/RecursiveRecordTypeMergeRhsNotRecordType.txt     | 2 +-
 dhall/tests/type-errors/unit/RightBiasedRecordMergeLhsNotRecord.txt   | 2 +-
 dhall/tests/type-errors/unit/RightBiasedRecordMergeRhsNotRecord.txt   | 2 +-
 dhall/tests/type-errors/unit/TextLiteralInterpolateNotText.txt        | 2 +-
 dhall/tests/type-errors/unit/TypeAnnotationWrong.txt                  | 2 +-
 dhall/tests/type-errors/unit/UnionConstructorFieldNotPresent.txt      | 2 +-
 dhall/tests/type-errors/unit/UnionTypeMixedKinds3.txt                 | 2 +-
 dhall/tests/type-errors/unit/UnionTypeNotType.txt                     | 2 +-
 45 files changed, 47 insertions(+), 47 deletions(-)

(limited to 'dhall')

diff --git a/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldName.txt b/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldName.txt
index e15da48..3f737c2 100644
--- a/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldName.txt
+++ b/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldName.txt
@@ -1 +1 @@
-Type error: Unhandled error: AnnotMismatch(Value@Unevaled { value: PartialExpr(RecordLit(DupTreeMap { map: {Label("x"): [Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@Unevaled { value: AppliedBuiltin(Natural, []), type: Type } }]}, size: 1 })), type: Value@WHNF { value: RecordType({Label("x"): Value@Unevaled { value: AppliedBuiltin(Natural, []), type: Type }}), type: Type } }, Value@WHNF { value: RecordType({Label("y"): Value@Unevaled { value: AppliedBuiltin(Natural, []), type: Type }}), type: Type })
+Type error: Unhandled error: AnnotMismatch(Value@Unevaled { value: PartialExpr(RecordLit(DupTreeMap { map: {Label("x"): [Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@Unevaled { value: AppliedBuiltin(Natural, [], []), type: Type } }]}, size: 1 })), type: Value@WHNF { value: RecordType({Label("x"): Value@Unevaled { value: AppliedBuiltin(Natural, [], []), type: Type }}), type: Type } }, Value@WHNF { value: RecordType({Label("y"): Value@Unevaled { value: AppliedBuiltin(Natural, [], []), type: Type }}), type: Type })
diff --git a/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldType.txt b/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldType.txt
index 16b2d83..d211716 100644
--- a/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldType.txt
+++ b/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldType.txt
@@ -1 +1 @@
-Type error: Unhandled error: AnnotMismatch(Value@Unevaled { value: PartialExpr(RecordLit(DupTreeMap { map: {Label("x"): [Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } }]}, size: 1 })), type: Value@WHNF { value: RecordType({Label("x"): Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type }}), type: Type } }, Value@WHNF { value: RecordType({Label("x"): Value@WHNF { value: AppliedBuiltin(Text, []), type: Type }}), type: Type })
+Type error: Unhandled error: AnnotMismatch(Value@Unevaled { value: PartialExpr(RecordLit(DupTreeMap { map: {Label("x"): [Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } }]}, size: 1 })), type: Value@WHNF { value: RecordType({Label("x"): Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type }}), type: Type } }, Value@WHNF { value: RecordType({Label("x"): Value@WHNF { value: AppliedBuiltin(Text, [], []), type: Type }}), type: Type })
diff --git a/dhall/tests/type-errors/unit/AssertDoubleZeros.txt b/dhall/tests/type-errors/unit/AssertDoubleZeros.txt
index d9df5c7..6886495 100644
--- a/dhall/tests/type-errors/unit/AssertDoubleZeros.txt
+++ b/dhall/tests/type-errors/unit/AssertDoubleZeros.txt
@@ -1 +1 @@
-Type error: Unhandled error: AssertMismatch(Value@WHNF { value: DoubleLit(NaiveDouble(-0.0)), type: Value@WHNF { value: AppliedBuiltin(Double, []), type: Type } }, Value@WHNF { value: DoubleLit(NaiveDouble(0.0)), type: Value@WHNF { value: AppliedBuiltin(Double, []), type: Type } })
+Type error: Unhandled error: AssertMismatch(Value@WHNF { value: DoubleLit(NaiveDouble(-0.0)), type: Value@WHNF { value: AppliedBuiltin(Double, [], []), type: Type } }, Value@WHNF { value: DoubleLit(NaiveDouble(0.0)), type: Value@WHNF { value: AppliedBuiltin(Double, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/AssertTriviallyFalse.txt b/dhall/tests/type-errors/unit/AssertTriviallyFalse.txt
index c7bbf8d..6f8e4a7 100644
--- a/dhall/tests/type-errors/unit/AssertTriviallyFalse.txt
+++ b/dhall/tests/type-errors/unit/AssertTriviallyFalse.txt
@@ -1 +1 @@
-Type error: Unhandled error: AssertMismatch(Value@WHNF { value: NaturalLit(1), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } }, Value@WHNF { value: NaturalLit(2), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } })
+Type error: Unhandled error: AssertMismatch(Value@WHNF { value: NaturalLit(1), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } }, Value@WHNF { value: NaturalLit(2), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/EquivalenceNotSameType.txt b/dhall/tests/type-errors/unit/EquivalenceNotSameType.txt
index 4dbe2ad..bdbe0e4 100644
--- a/dhall/tests/type-errors/unit/EquivalenceNotSameType.txt
+++ b/dhall/tests/type-errors/unit/EquivalenceNotSameType.txt
@@ -1 +1 @@
-Type error: Unhandled error: EquivalenceTypeMismatch(Value@Unevaled { value: PartialExpr(BoolLit(false)), type: Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type } }, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } })
+Type error: Unhandled error: EquivalenceTypeMismatch(Value@Unevaled { value: PartialExpr(BoolLit(false)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } }, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/EquivalenceNotTerms.txt b/dhall/tests/type-errors/unit/EquivalenceNotTerms.txt
index dbce067..23b37d3 100644
--- a/dhall/tests/type-errors/unit/EquivalenceNotTerms.txt
+++ b/dhall/tests/type-errors/unit/EquivalenceNotTerms.txt
@@ -1 +1 @@
-Type error: Unhandled error: EquivalenceArgumentMustBeTerm(true, Value@Unevaled { value: AppliedBuiltin(Bool, []), type: Type })
+Type error: Unhandled error: EquivalenceArgumentMustBeTerm(true, Value@Unevaled { value: AppliedBuiltin(Bool, [], []), type: Type })
diff --git a/dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt b/dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt
index 3bb1492..8507ccf 100644
--- a/dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt
+++ b/dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt
@@ -4,10 +4,10 @@
 1 | (λ(_ : Natural) → _) True␊
   |                      ^--^
   |
-  = This argument has type Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type }
+  = This argument has type Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type }
  --> 1:8
   |
 1 | (λ(_ : Natural) → _) True␊
   |        ^-----^
   |
-  = But the function expected an argument of type Value@NF { value: AppliedBuiltin(Natural, []), type: Type }
+  = But the function expected an argument of type Value@NF { value: AppliedBuiltin(Natural, [], []), type: Type }
diff --git a/dhall/tests/type-errors/unit/IfBranchesNotMatch.txt b/dhall/tests/type-errors/unit/IfBranchesNotMatch.txt
index 262e54f..4d28695 100644
--- a/dhall/tests/type-errors/unit/IfBranchesNotMatch.txt
+++ b/dhall/tests/type-errors/unit/IfBranchesNotMatch.txt
@@ -1 +1 @@
-Type error: Unhandled error: IfBranchMismatch(Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } }, Value@Unevaled { value: PartialExpr(TextLit(InterpolatedText { head: "", tail: [] })), type: Value@WHNF { value: AppliedBuiltin(Text, []), type: Type } })
+Type error: Unhandled error: IfBranchMismatch(Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } }, Value@Unevaled { value: PartialExpr(TextLit(InterpolatedText { head: "", tail: [] })), type: Value@WHNF { value: AppliedBuiltin(Text, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/IfNotBool.txt b/dhall/tests/type-errors/unit/IfNotBool.txt
index 64c0465..665093f 100644
--- a/dhall/tests/type-errors/unit/IfNotBool.txt
+++ b/dhall/tests/type-errors/unit/IfNotBool.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidPredicate(Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } })
+Type error: Unhandled error: InvalidPredicate(Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/LetWithWrongAnnotation.txt b/dhall/tests/type-errors/unit/LetWithWrongAnnotation.txt
index 0862162..61096d0 100644
--- a/dhall/tests/type-errors/unit/LetWithWrongAnnotation.txt
+++ b/dhall/tests/type-errors/unit/LetWithWrongAnnotation.txt
@@ -1 +1 @@
-Type error: Unhandled error: AnnotMismatch(Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type } }, Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type })
+Type error: Unhandled error: AnnotMismatch(Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } }, Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type })
diff --git a/dhall/tests/type-errors/unit/ListLiteralTypesNotMatch.txt b/dhall/tests/type-errors/unit/ListLiteralTypesNotMatch.txt
index 7916dbb..2355b7c 100644
--- a/dhall/tests/type-errors/unit/ListLiteralTypesNotMatch.txt
+++ b/dhall/tests/type-errors/unit/ListLiteralTypesNotMatch.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidListElement(1, Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type }, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } })
+Type error: Unhandled error: InvalidListElement(1, Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type }, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt b/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt
index ae36eef..19f375a 100644
--- a/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt
+++ b/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt
@@ -10,4 +10,4 @@
 1 | merge { x = λ(_ : Bool) → _ } (< x : Natural >.x 1)␊
   |                   ^--^
   |
-  = But the function expected an argument of type Value@NF { value: AppliedBuiltin(Bool, []), type: Type }
+  = But the function expected an argument of type Value@NF { value: AppliedBuiltin(Bool, [], []), type: Type }
diff --git a/dhall/tests/type-errors/unit/MergeLhsNotRecord.txt b/dhall/tests/type-errors/unit/MergeLhsNotRecord.txt
index da600de..785fc63 100644
--- a/dhall/tests/type-errors/unit/MergeLhsNotRecord.txt
+++ b/dhall/tests/type-errors/unit/MergeLhsNotRecord.txt
@@ -1 +1 @@
-Type error: Unhandled error: Merge1ArgMustBeRecord(Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type } })
+Type error: Unhandled error: Merge1ArgMustBeRecord(Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/MergeRhsNotUnion.txt b/dhall/tests/type-errors/unit/MergeRhsNotUnion.txt
index db93650..8954538 100644
--- a/dhall/tests/type-errors/unit/MergeRhsNotUnion.txt
+++ b/dhall/tests/type-errors/unit/MergeRhsNotUnion.txt
@@ -1 +1 @@
-Type error: Unhandled error: Merge2ArgMustBeUnionOrOptional(Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type } })
+Type error: Unhandled error: Merge2ArgMustBeUnionOrOptional(Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt b/dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt
index 02a9c45..784fd8a 100644
--- a/dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt
+++ b/dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt
@@ -9,5 +9,5 @@
 1 | Natural/subtract True True␊
   |                  ^--^
   |
-  = This argument has type Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type }
-[unknown location] But the function expected an argument of type Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type }
+  = This argument has type Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type }
+[unknown location] But the function expected an argument of type Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type }
diff --git a/dhall/tests/type-errors/unit/OperatorAndNotBool.txt b/dhall/tests/type-errors/unit/OperatorAndNotBool.txt
index a4346f2..b9314fb 100644
--- a/dhall/tests/type-errors/unit/OperatorAndNotBool.txt
+++ b/dhall/tests/type-errors/unit/OperatorAndNotBool.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(BoolAnd, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch(BoolAnd, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/OperatorEqualNotBool.txt b/dhall/tests/type-errors/unit/OperatorEqualNotBool.txt
index 57f9095..253e2f2 100644
--- a/dhall/tests/type-errors/unit/OperatorEqualNotBool.txt
+++ b/dhall/tests/type-errors/unit/OperatorEqualNotBool.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(BoolEQ, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch(BoolEQ, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/OperatorListConcatenateLhsNotList.txt b/dhall/tests/type-errors/unit/OperatorListConcatenateLhsNotList.txt
index 2bcb4fc..735d101 100644
--- a/dhall/tests/type-errors/unit/OperatorListConcatenateLhsNotList.txt
+++ b/dhall/tests/type-errors/unit/OperatorListConcatenateLhsNotList.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(ListAppend, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch(ListAppend, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/OperatorListConcatenateListsNotMatch.txt b/dhall/tests/type-errors/unit/OperatorListConcatenateListsNotMatch.txt
index e314702..b931c01 100644
--- a/dhall/tests/type-errors/unit/OperatorListConcatenateListsNotMatch.txt
+++ b/dhall/tests/type-errors/unit/OperatorListConcatenateListsNotMatch.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(ListAppend, Value@Unevaled { value: PartialExpr(NEListLit([Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } }])), type: Value@WHNF { value: AppliedBuiltin(List, [Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type }]), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch(ListAppend, Value@Unevaled { value: PartialExpr(NEListLit([Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } }])), type: Value@WHNF { value: AppliedBuiltin(List, [Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type }], [Value@WHNF { value: Pi(Binder(`_`), Type, Type), type: Kind }]), type: Type } })
diff --git a/dhall/tests/type-errors/unit/OperatorListConcatenateNotListsButMatch.txt b/dhall/tests/type-errors/unit/OperatorListConcatenateNotListsButMatch.txt
index 2bcb4fc..735d101 100644
--- a/dhall/tests/type-errors/unit/OperatorListConcatenateNotListsButMatch.txt
+++ b/dhall/tests/type-errors/unit/OperatorListConcatenateNotListsButMatch.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(ListAppend, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch(ListAppend, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/OperatorListConcatenateRhsNotList.txt b/dhall/tests/type-errors/unit/OperatorListConcatenateRhsNotList.txt
index 2bcb4fc..735d101 100644
--- a/dhall/tests/type-errors/unit/OperatorListConcatenateRhsNotList.txt
+++ b/dhall/tests/type-errors/unit/OperatorListConcatenateRhsNotList.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(ListAppend, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch(ListAppend, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/OperatorNotEqualNotBool.txt b/dhall/tests/type-errors/unit/OperatorNotEqualNotBool.txt
index 32b3549..c3c83b1 100644
--- a/dhall/tests/type-errors/unit/OperatorNotEqualNotBool.txt
+++ b/dhall/tests/type-errors/unit/OperatorNotEqualNotBool.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(BoolNE, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch(BoolNE, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/OperatorOrNotBool.txt b/dhall/tests/type-errors/unit/OperatorOrNotBool.txt
index f91bd83..32caf35 100644
--- a/dhall/tests/type-errors/unit/OperatorOrNotBool.txt
+++ b/dhall/tests/type-errors/unit/OperatorOrNotBool.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(BoolOr, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch(BoolOr, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/OperatorPlusNotNatural.txt b/dhall/tests/type-errors/unit/OperatorPlusNotNatural.txt
index 9194f3a..4e578c4 100644
--- a/dhall/tests/type-errors/unit/OperatorPlusNotNatural.txt
+++ b/dhall/tests/type-errors/unit/OperatorPlusNotNatural.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(NaturalPlus, Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch(NaturalPlus, Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/OperatorTextConcatenateLhsNotText.txt b/dhall/tests/type-errors/unit/OperatorTextConcatenateLhsNotText.txt
index e67e9e5..58d4b23 100644
--- a/dhall/tests/type-errors/unit/OperatorTextConcatenateLhsNotText.txt
+++ b/dhall/tests/type-errors/unit/OperatorTextConcatenateLhsNotText.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(TextAppend, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch(TextAppend, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/OperatorTextConcatenateRhsNotText.txt b/dhall/tests/type-errors/unit/OperatorTextConcatenateRhsNotText.txt
index e67e9e5..58d4b23 100644
--- a/dhall/tests/type-errors/unit/OperatorTextConcatenateRhsNotText.txt
+++ b/dhall/tests/type-errors/unit/OperatorTextConcatenateRhsNotText.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(TextAppend, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch(TextAppend, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/OperatorTimesNotNatural.txt b/dhall/tests/type-errors/unit/OperatorTimesNotNatural.txt
index 8146ba9..8caf338 100644
--- a/dhall/tests/type-errors/unit/OperatorTimesNotNatural.txt
+++ b/dhall/tests/type-errors/unit/OperatorTimesNotNatural.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(NaturalTimes, Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch(NaturalTimes, Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxAbsent.txt b/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxAbsent.txt
index c319c81..e524a07 100644
--- a/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxAbsent.txt
+++ b/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxAbsent.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidListType(Value@WHNF { value: AppliedBuiltin(Optional, [Value@Unevaled { value: AppliedBuiltin(Bool, []), type: Type }]), type: Type })
+Type error: Unhandled error: InvalidListType(Value@WHNF { value: AppliedBuiltin(Optional, [Value@Unevaled { value: AppliedBuiltin(Bool, [], []), type: Type }], [Value@WHNF { value: Pi(Binder(`_`), Type, Type), type: Kind }]), type: Type })
diff --git a/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxPresent.txt b/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxPresent.txt
index 99df27c..5ff6a69 100644
--- a/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxPresent.txt
+++ b/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxPresent.txt
@@ -1 +1 @@
-Type error: Unhandled error: AnnotMismatch(Value@Unevaled { value: PartialExpr(NEListLit([Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@Unevaled { value: AppliedBuiltin(Natural, []), type: Type } }])), type: Value@WHNF { value: AppliedBuiltin(List, [Value@Unevaled { value: AppliedBuiltin(Natural, []), type: Type }]), type: Type } }, Value@WHNF { value: AppliedBuiltin(Optional, [Value@Unevaled { value: AppliedBuiltin(Natural, []), type: Type }]), type: Type })
+Type error: Unhandled error: AnnotMismatch(Value@Unevaled { value: PartialExpr(NEListLit([Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@Unevaled { value: AppliedBuiltin(Natural, [], []), type: Type } }])), type: Value@WHNF { value: AppliedBuiltin(List, [Value@Unevaled { value: AppliedBuiltin(Natural, [], []), type: Type }], [Value@WHNF { value: Pi(Binder(`_`), Type, Type), type: Kind }]), type: Type } }, Value@WHNF { value: AppliedBuiltin(Optional, [Value@Unevaled { value: AppliedBuiltin(Natural, [], []), type: Type }], [Value@WHNF { value: Pi(Binder(`_`), Type, Type), type: Kind }]), type: Type })
diff --git a/dhall/tests/type-errors/unit/RecordSelectionNotRecord.txt b/dhall/tests/type-errors/unit/RecordSelectionNotRecord.txt
index 27db6a2..292ab0e 100644
--- a/dhall/tests/type-errors/unit/RecordSelectionNotRecord.txt
+++ b/dhall/tests/type-errors/unit/RecordSelectionNotRecord.txt
@@ -1 +1 @@
-Type error: Unhandled error: NotARecord(Label("x"), Value@WHNF { value: BoolLit(true), type: Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type } })
+Type error: Unhandled error: NotARecord(Label("x"), Value@WHNF { value: BoolLit(true), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/RecordSelectionTypeNotUnionType.txt b/dhall/tests/type-errors/unit/RecordSelectionTypeNotUnionType.txt
index 36c8e28..dff292e 100644
--- a/dhall/tests/type-errors/unit/RecordSelectionTypeNotUnionType.txt
+++ b/dhall/tests/type-errors/unit/RecordSelectionTypeNotUnionType.txt
@@ -1 +1 @@
-Type error: Unhandled error: NotARecord(Label("x"), Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type })
+Type error: Unhandled error: NotARecord(Label("x"), Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type })
diff --git a/dhall/tests/type-errors/unit/RecordTypeValueMember.txt b/dhall/tests/type-errors/unit/RecordTypeValueMember.txt
index 72d4316..ed3fd6a 100644
--- a/dhall/tests/type-errors/unit/RecordTypeValueMember.txt
+++ b/dhall/tests/type-errors/unit/RecordTypeValueMember.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidFieldType(Label("x"), Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type } })
+Type error: Unhandled error: InvalidFieldType(Label("x"), Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/RecursiveRecordMergeLhsNotRecord.txt b/dhall/tests/type-errors/unit/RecursiveRecordMergeLhsNotRecord.txt
index 42cdf65..27ed928 100644
--- a/dhall/tests/type-errors/unit/RecursiveRecordMergeLhsNotRecord.txt
+++ b/dhall/tests/type-errors/unit/RecursiveRecordMergeLhsNotRecord.txt
@@ -1 +1 @@
-Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type })
+Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type })
diff --git a/dhall/tests/type-errors/unit/RecursiveRecordMergeOverlapping.txt b/dhall/tests/type-errors/unit/RecursiveRecordMergeOverlapping.txt
index 42cdf65..27ed928 100644
--- a/dhall/tests/type-errors/unit/RecursiveRecordMergeOverlapping.txt
+++ b/dhall/tests/type-errors/unit/RecursiveRecordMergeOverlapping.txt
@@ -1 +1 @@
-Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type })
+Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type })
diff --git a/dhall/tests/type-errors/unit/RecursiveRecordMergeRhsNotRecord.txt b/dhall/tests/type-errors/unit/RecursiveRecordMergeRhsNotRecord.txt
index 42cdf65..27ed928 100644
--- a/dhall/tests/type-errors/unit/RecursiveRecordMergeRhsNotRecord.txt
+++ b/dhall/tests/type-errors/unit/RecursiveRecordMergeRhsNotRecord.txt
@@ -1 +1 @@
-Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type })
+Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type })
diff --git a/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeLhsNotRecordType.txt b/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeLhsNotRecordType.txt
index 42cdf65..27ed928 100644
--- a/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeLhsNotRecordType.txt
+++ b/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeLhsNotRecordType.txt
@@ -1 +1 @@
-Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type })
+Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type })
diff --git a/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeOverlapping.txt b/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeOverlapping.txt
index 42cdf65..27ed928 100644
--- a/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeOverlapping.txt
+++ b/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeOverlapping.txt
@@ -1 +1 @@
-Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type })
+Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type })
diff --git a/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeRhsNotRecordType.txt b/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeRhsNotRecordType.txt
index 42cdf65..27ed928 100644
--- a/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeRhsNotRecordType.txt
+++ b/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeRhsNotRecordType.txt
@@ -1 +1 @@
-Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type })
+Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type })
diff --git a/dhall/tests/type-errors/unit/RightBiasedRecordMergeLhsNotRecord.txt b/dhall/tests/type-errors/unit/RightBiasedRecordMergeLhsNotRecord.txt
index 9a2913b..fbb410f 100644
--- a/dhall/tests/type-errors/unit/RightBiasedRecordMergeLhsNotRecord.txt
+++ b/dhall/tests/type-errors/unit/RightBiasedRecordMergeLhsNotRecord.txt
@@ -1 +1 @@
-Type error: Unhandled error: MustCombineRecord(Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type } })
+Type error: Unhandled error: MustCombineRecord(Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/RightBiasedRecordMergeRhsNotRecord.txt b/dhall/tests/type-errors/unit/RightBiasedRecordMergeRhsNotRecord.txt
index 9a2913b..fbb410f 100644
--- a/dhall/tests/type-errors/unit/RightBiasedRecordMergeRhsNotRecord.txt
+++ b/dhall/tests/type-errors/unit/RightBiasedRecordMergeRhsNotRecord.txt
@@ -1 +1 @@
-Type error: Unhandled error: MustCombineRecord(Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type } })
+Type error: Unhandled error: MustCombineRecord(Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/TextLiteralInterpolateNotText.txt b/dhall/tests/type-errors/unit/TextLiteralInterpolateNotText.txt
index ba2aecd..feb6b2e 100644
--- a/dhall/tests/type-errors/unit/TextLiteralInterpolateNotText.txt
+++ b/dhall/tests/type-errors/unit/TextLiteralInterpolateNotText.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidTextInterpolation(Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } })
+Type error: Unhandled error: InvalidTextInterpolation(Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
diff --git a/dhall/tests/type-errors/unit/TypeAnnotationWrong.txt b/dhall/tests/type-errors/unit/TypeAnnotationWrong.txt
index 77ff57f..869e9c3 100644
--- a/dhall/tests/type-errors/unit/TypeAnnotationWrong.txt
+++ b/dhall/tests/type-errors/unit/TypeAnnotationWrong.txt
@@ -1 +1 @@
-Type error: Unhandled error: AnnotMismatch(Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, []), type: Type } }, Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type })
+Type error: Unhandled error: AnnotMismatch(Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } }, Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type })
diff --git a/dhall/tests/type-errors/unit/UnionConstructorFieldNotPresent.txt b/dhall/tests/type-errors/unit/UnionConstructorFieldNotPresent.txt
index 7b2e610..eb3e09a 100644
--- a/dhall/tests/type-errors/unit/UnionConstructorFieldNotPresent.txt
+++ b/dhall/tests/type-errors/unit/UnionConstructorFieldNotPresent.txt
@@ -1 +1 @@
-Type error: Unhandled error: MissingUnionField(Label("y"), Value@WHNF { value: UnionType({Label("x"): Some(Value@Unevaled { value: AppliedBuiltin(Bool, []), type: Type })}), type: Type })
+Type error: Unhandled error: MissingUnionField(Label("y"), Value@WHNF { value: UnionType({Label("x"): Some(Value@Unevaled { value: AppliedBuiltin(Bool, [], []), type: Type })}), type: Type })
diff --git a/dhall/tests/type-errors/unit/UnionTypeMixedKinds3.txt b/dhall/tests/type-errors/unit/UnionTypeMixedKinds3.txt
index 83fc426..ded0e5c 100644
--- a/dhall/tests/type-errors/unit/UnionTypeMixedKinds3.txt
+++ b/dhall/tests/type-errors/unit/UnionTypeMixedKinds3.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidFieldType(Label("y"), Value@Unevaled { value: AppliedBuiltin(Bool, []), type: Type })
+Type error: Unhandled error: InvalidFieldType(Label("y"), Value@Unevaled { value: AppliedBuiltin(Bool, [], []), type: Type })
diff --git a/dhall/tests/type-errors/unit/UnionTypeNotType.txt b/dhall/tests/type-errors/unit/UnionTypeNotType.txt
index 72d4316..ed3fd6a 100644
--- a/dhall/tests/type-errors/unit/UnionTypeNotType.txt
+++ b/dhall/tests/type-errors/unit/UnionTypeNotType.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidFieldType(Label("x"), Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, []), type: Type } })
+Type error: Unhandled error: InvalidFieldType(Label("x"), Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
-- 
cgit v1.2.3


From a24f2d1367b2848779014c7bb3ecfe6bfbcff7d7 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 24 Jan 2020 18:38:30 +0000
Subject: Fix some variable shifting failures

---
 dhall/src/semantics/core/context.rs    | 17 +++++++++++++++--
 dhall/src/semantics/core/value.rs      | 18 +++++++++++-------
 dhall/src/semantics/nze/nzexpr.rs      |  8 ++++++++
 dhall/src/semantics/phase/normalize.rs | 24 +++++++++++++++++++-----
 4 files changed, 53 insertions(+), 14 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index 7972a20..0e62fef 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -2,7 +2,8 @@ use crate::error::TypeError;
 use crate::semantics::core::value::Value;
 use crate::semantics::core::value::ValueKind;
 use crate::semantics::core::var::{AlphaVar, Binder};
-use crate::semantics::nze::NzVar;
+use crate::semantics::nze::{NzVar, QuoteEnv};
+use crate::semantics::phase::normalize::{NzEnv, NzEnvItem};
 use crate::syntax::{Label, V};
 
 #[derive(Debug, Clone)]
@@ -69,7 +70,19 @@ impl TyCtx {
                 ValueKind::Var(AlphaVar::default(), NzVar::new(var_idx)),
                 t.clone(),
             ),
-            CtxItem::Replaced(v) => v.clone(),
+            CtxItem::Replaced(v) => v.clone()
+                // .to_tyexpr(QuoteEnv::construct(var_idx))
+                // .normalize_whnf(&NzEnv::construct(
+                //     self.ctx
+                //         .iter()
+                //         .filter_map(|(_, i)| match i {
+                //             CtxItem::Kept(t) => {
+                //                 Some(NzEnvItem::Kept(t.clone()))
+                //             }
+                //             CtxItem::Replaced(_) => None,
+                //         })
+                //         .collect(),
+                // )),
         };
         // Can't fail because delta is positive
         let v = v.shift(shift_delta, &AlphaVar::default()).unwrap();
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 96bb99a..11d8bd8 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -185,7 +185,7 @@ impl Value {
             self.normalize_nf();
         }
 
-        self.to_tyexpr(QuoteEnv::new()).to_expr(opts)
+        self.to_tyexpr_noenv().to_expr(opts)
     }
     pub(crate) fn to_whnf_ignore_type(&self) -> ValueKind<Value> {
         self.as_whnf().clone()
@@ -292,11 +292,9 @@ impl Value {
 
     pub fn to_tyexpr(&self, qenv: QuoteEnv) -> TyExpr {
         let tye = match &*self.as_kind() {
-            ValueKind::Var(v, _w) => {
-                TyExprKind::Var(*v)
-                // TODO: Only works when we don't normalize under lambdas
-                // TyExprKind::Var(qenv.lookup(w))
-            }
+            // ValueKind::Var(v, _w) => TyExprKind::Var(*v),
+            // TODO: Only works when we don't normalize under lambdas
+            ValueKind::Var(_v, w) => TyExprKind::Var(qenv.lookup(w)),
             ValueKind::LamClosure {
                 binder,
                 annot,
@@ -611,7 +609,13 @@ impl ValueKind<Value> {
 
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
         Some(match self {
-            ValueKind::Var(v, w) => ValueKind::Var(v.shift(delta, var)?, *w),
+            ValueKind::Var(v, w) if var.idx() <= v.idx() => {
+                ValueKind::Var(v.shift(delta, var)?, *w)
+            }
+            ValueKind::Var(v, w) => {
+                ValueKind::Var(v.shift(delta, var)?, w.shift(delta))
+            }
+            // ValueKind::Var(v, w) => ValueKind::Var(v.shift(delta, var)?, *w),
             _ => self.traverse_ref_with_special_handling_of_binders(
                 |x| Ok(x.shift(delta, var)?),
                 |_, _, x| Ok(x.shift(delta, &var.under_binder())?),
diff --git a/dhall/src/semantics/nze/nzexpr.rs b/dhall/src/semantics/nze/nzexpr.rs
index 723c895..49aa704 100644
--- a/dhall/src/semantics/nze/nzexpr.rs
+++ b/dhall/src/semantics/nze/nzexpr.rs
@@ -217,6 +217,9 @@ impl QuoteEnv {
     pub fn new() -> Self {
         QuoteEnv { size: 0 }
     }
+    pub fn construct(size: usize) -> Self {
+        QuoteEnv { size }
+    }
     pub fn insert(&self) -> Self {
         QuoteEnv {
             size: self.size + 1,
@@ -231,6 +234,11 @@ impl NzVar {
     pub fn new(idx: usize) -> Self {
         NzVar { idx }
     }
+    pub fn shift(&self, delta: isize) -> Self {
+        NzVar {
+            idx: (self.idx as isize + delta) as usize,
+        }
+    }
 }
 
 impl TyExpr {
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index ac60ce0..3ddfb84 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -12,8 +12,8 @@ use crate::semantics::{
 use crate::syntax;
 use crate::syntax::Const::Type;
 use crate::syntax::{
-    BinOp, Builtin, ExprKind, InterpolatedText, InterpolatedTextContents,
-    Label, NaiveDouble,
+    BinOp, Builtin, Const, ExprKind, InterpolatedText,
+    InterpolatedTextContents, Label, NaiveDouble,
 };
 
 // Ad-hoc macro to help construct closures
@@ -822,7 +822,7 @@ pub(crate) fn normalize_whnf(
 }
 
 #[derive(Debug, Clone)]
-enum NzEnvItem {
+pub(crate) enum NzEnvItem {
     // Variable is bound with given type
     Kept(Value),
     // Variable has been replaced by corresponding value
@@ -838,6 +838,9 @@ impl NzEnv {
     pub fn new() -> Self {
         NzEnv { items: Vec::new() }
     }
+    pub fn construct(items: Vec<NzEnvItem>) -> Self {
+        NzEnv { items }
+    }
 
     pub fn insert_type(&self, t: Value) -> Self {
         let mut env = self.clone();
@@ -851,9 +854,16 @@ impl NzEnv {
     }
     pub fn lookup_val(&self, var: &AlphaVar) -> Value {
         let idx = self.items.len() - 1 - var.idx();
+        let var_idx = self.items[..idx]
+            .iter()
+            .filter(|i| match i {
+                NzEnvItem::Kept(_) => true,
+                NzEnvItem::Replaced(_) => false,
+            })
+            .count();
         match &self.items[idx] {
             NzEnvItem::Kept(ty) => Value::from_kind_and_type_whnf(
-                ValueKind::Var(var.clone(), NzVar::new(idx)),
+                ValueKind::Var(var.clone(), NzVar::new(var_idx)),
                 ty.clone(),
             ),
             NzEnvItem::Replaced(x) => x.clone(),
@@ -863,7 +873,11 @@ impl NzEnv {
 
 /// Normalize a TyExpr into WHNF
 pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> Value {
-    let ty = tye.get_type().unwrap();
+    let ty = match tye.get_type() {
+        Ok(ty) => ty,
+        Err(_) => return Value::from_const(Const::Sort),
+    };
+
     let kind = match tye.kind() {
         TyExprKind::Var(var) => return env.lookup_val(var),
         TyExprKind::Expr(ExprKind::Lam(binder, annot, body)) => {
-- 
cgit v1.2.3


From 9e9b556ee2212540ba43d85249df8c763aa6da2b Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 24 Jan 2020 21:32:48 +0000
Subject: Postpone fixing Foo/build builtins

---
 dhall/build.rs | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'dhall')

diff --git a/dhall/build.rs b/dhall/build.rs
index c95a26d..ed8d98b 100644
--- a/dhall/build.rs
+++ b/dhall/build.rs
@@ -276,6 +276,13 @@ fn generate_tests() -> std::io::Result<()> {
                     // TODO: record completion
                     || path == "simple/completion"
                     || path == "unit/Completion"
+                    // TODO: fix variables in Foo/build
+                    || path == "unit/ListBuildFoldFusion"
+                    || path == "unit/ListBuildImplementation"
+                    || path == "unit/NaturalBuildFoldFusion"
+                    || path == "unit/NaturalBuildImplementation"
+                    || path == "unit/OptionalBuildFoldFusion"
+                    || path == "unit/OptionalBuildImplementation"
             }),
             input_type: FileType::Text,
             output_type: Some(FileType::Text),
-- 
cgit v1.2.3


From b72f0968ac19058b9cc513ab0ed1785133232a3d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 24 Jan 2020 21:33:21 +0000
Subject: Implement basic typecheck with new approach

---
 dhall/src/semantics/core/context.rs    |   5 +-
 dhall/src/semantics/phase/normalize.rs |   1 +
 dhall/src/semantics/tck/typecheck.rs   | 147 +++++++++++++++++++++++++++++++++
 dhall/src/tests.rs                     |  25 ++++--
 4 files changed, 166 insertions(+), 12 deletions(-)
 create mode 100644 dhall/src/semantics/tck/typecheck.rs

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index 0e62fef..9749c50 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -2,8 +2,8 @@ use crate::error::TypeError;
 use crate::semantics::core::value::Value;
 use crate::semantics::core::value::ValueKind;
 use crate::semantics::core::var::{AlphaVar, Binder};
-use crate::semantics::nze::{NzVar, QuoteEnv};
-use crate::semantics::phase::normalize::{NzEnv, NzEnvItem};
+use crate::semantics::nze::NzVar;
+// use crate::semantics::phase::normalize::{NzEnv, NzEnvItem};
 use crate::syntax::{Label, V};
 
 #[derive(Debug, Clone)]
@@ -71,7 +71,6 @@ impl TyCtx {
                 t.clone(),
             ),
             CtxItem::Replaced(v) => v.clone()
-                // .to_tyexpr(QuoteEnv::construct(var_idx))
                 // .normalize_whnf(&NzEnv::construct(
                 //     self.ctx
                 //         .iter()
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index 3ddfb84..e848601 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -1,3 +1,4 @@
+#![allow(dead_code)]
 use std::collections::HashMap;
 use std::convert::TryInto;
 
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
new file mode 100644
index 0000000..aab5f83
--- /dev/null
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -0,0 +1,147 @@
+#![allow(dead_code)]
+#![allow(unused_variables)]
+#![allow(unreachable_code)]
+#![allow(unused_imports)]
+use std::borrow::Cow;
+use std::cmp::max;
+use std::collections::HashMap;
+
+use crate::error::{TypeError, TypeMessage};
+use crate::semantics::core::context::TyCtx;
+use crate::semantics::nze::{NameEnv, QuoteEnv};
+use crate::semantics::phase::normalize::{merge_maps, NzEnv};
+use crate::semantics::phase::Normalized;
+use crate::semantics::{
+    AlphaVar, Binder, Closure, TyExpr, TyExprKind, Type, Value, ValueKind,
+};
+use crate::syntax;
+use crate::syntax::{
+    Builtin, Const, Expr, ExprKind, InterpolatedTextContents, Label, Span,
+    UnspannedExpr, V,
+};
+
+#[derive(Debug, Clone)]
+pub(crate) struct TyEnv {
+    names: NameEnv,
+    items: NzEnv,
+}
+
+impl TyEnv {
+    pub fn new() -> Self {
+        TyEnv {
+            names: NameEnv::new(),
+            items: NzEnv::new(),
+        }
+    }
+    pub fn as_quoteenv(&self) -> QuoteEnv {
+        self.names.as_quoteenv()
+    }
+    pub fn as_nzenv(&self) -> &NzEnv {
+        &self.items
+    }
+    pub fn as_nameenv(&self) -> &NameEnv {
+        &self.names
+    }
+
+    pub fn insert_type(&self, x: &Label, t: Value) -> Self {
+        TyEnv {
+            names: self.names.insert(x),
+            items: self.items.insert_type(t),
+        }
+    }
+    pub fn insert_value(&self, x: &Label, e: Value) -> Self {
+        TyEnv {
+            names: self.names.insert(x),
+            items: self.items.insert_value(e),
+        }
+    }
+    pub fn lookup_var(&self, var: &V<Label>) -> Option<(TyExprKind, Value)> {
+        let var = self.names.unlabel_var(var)?;
+        let ty = self.lookup_val(&var).get_type().unwrap();
+        Some((TyExprKind::Var(var), ty))
+    }
+    pub fn lookup_val(&self, var: &AlphaVar) -> Value {
+        self.items.lookup_val(var)
+    }
+    pub fn size(&self) -> usize {
+        self.names.size()
+    }
+}
+
+/// Type-check an expression and return the expression alongside its type if type-checking
+/// succeeded, or an error if type-checking failed.
+fn type_with(env: &TyEnv, expr: Expr<Normalized>) -> Result<TyExpr, TypeError> {
+    let mkerr = || TypeError::new(TypeMessage::Sort);
+
+    match expr.as_ref() {
+        ExprKind::Var(var) => match env.lookup_var(&var) {
+            Some((e, ty)) => Ok(TyExpr::new(e, Some(ty), expr.span())),
+            None => Err(mkerr()),
+        },
+        ExprKind::Lam(binder, annot, body) => {
+            let annot = type_with(env, annot.clone())?;
+            let annot_nf = annot.normalize_whnf(env.as_nzenv());
+            let body = type_with(
+                &env.insert_type(&binder, annot_nf.clone()),
+                body.clone(),
+            )?;
+            let ty = Value::from_kind_and_type(
+                ValueKind::PiClosure {
+                    binder: Binder::new(binder.clone()),
+                    annot: annot_nf,
+                    closure: Closure::new(
+                        env.as_nzenv(),
+                        body.get_type()?.to_tyexpr(env.as_quoteenv()),
+                    ),
+                },
+                Value::from_const(Const::Type), // TODO: function_check
+            );
+            Ok(TyExpr::new(
+                TyExprKind::Expr(ExprKind::Lam(binder.clone(), annot, body)),
+                Some(ty),
+                expr.span(),
+            ))
+        }
+        ExprKind::Pi(binder, annot, body) => {
+            let annot = type_with(env, annot.clone())?;
+            let annot_nf = annot.normalize_whnf(env.as_nzenv());
+            let body = type_with(
+                &env.insert_type(binder, annot_nf.clone()),
+                body.clone(),
+            )?;
+            Ok(TyExpr::new(
+                TyExprKind::Expr(ExprKind::Pi(binder.clone(), annot, body)),
+                None, // TODO: function_check
+                expr.span(),
+            ))
+        }
+        kind => {
+            let kind = kind.traverse_ref(|e| type_with(env, e.clone()))?;
+            let ty = match &kind {
+                ExprKind::App(f, arg) => {
+                    let tf = f.get_type()?;
+                    let tf_borrow = tf.as_whnf();
+                    let (_expected_arg_ty, ty_closure) = match &*tf_borrow {
+                        ValueKind::PiClosure { annot, closure, .. } => {
+                            (annot, closure)
+                        }
+                        _ => return Err(mkerr()),
+                    };
+                    // if arg.get_type()? != *expected_arg_ty {
+                    //     return Err(mkerr());
+                    // }
+
+                    let arg_nf = arg.normalize_whnf(env.as_nzenv());
+                    ty_closure.apply(arg_nf)
+                }
+                _ => Value::from_const(Const::Type), // TODO
+            };
+
+            Ok(TyExpr::new(TyExprKind::Expr(kind), Some(ty), expr.span()))
+        }
+    }
+}
+
+pub(crate) fn typecheck(e: Expr<Normalized>) -> Result<TyExpr, TypeError> {
+    type_with(&TyEnv::new(), e)
+}
diff --git a/dhall/src/tests.rs b/dhall/src/tests.rs
index 4928c51..994a134 100644
--- a/dhall/src/tests.rs
+++ b/dhall/src/tests.rs
@@ -211,20 +211,27 @@ pub fn run_test(test: Test<'_>) -> Result<()> {
             //     .typecheck()?
             //     .normalize()
             //     .to_expr();
-            let expr = parse_file_str(&expr_file_path)?
-                .resolve()?
-                .typecheck()?
-                .to_value()
-                .to_tyexpr_noenv()
+            // let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
+            // let expr = crate::semantics::nze::nzexpr::typecheck(expr)?
+            //     .normalize()
+            //     .to_expr();
+            // let expr = parse_file_str(&expr_file_path)?
+            //     .resolve()?
+            //     .typecheck()?
+            //     .to_value()
+            //     .to_tyexpr_noenv()
+            //     .normalize_whnf_noenv()
+            //     .to_expr(crate::semantics::phase::ToExprOptions {
+            //         alpha: false,
+            //         normalize: true,
+            //     });
+            let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
+            let expr = crate::semantics::tck::typecheck::typecheck(expr)?
                 .normalize_whnf_noenv()
                 .to_expr(crate::semantics::phase::ToExprOptions {
                     alpha: false,
                     normalize: true,
                 });
-            // let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
-            // let expr = crate::semantics::nze::nzexpr::typecheck(expr)?
-            //     .normalize()
-            //     .to_expr();
             let expected = parse_file_str(&expected_file_path)?.to_expr();
 
             assert_eq_display!(expr, expected);
-- 
cgit v1.2.3


From 70e6e3a06c05cfe7d8ca3d6f072e7182639c147f Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 25 Jan 2020 10:15:17 +0000
Subject: Typecheck more cases

---
 dhall/src/error/mod.rs                 |   1 +
 dhall/src/semantics/phase/normalize.rs |  13 ++-
 dhall/src/semantics/phase/typecheck.rs |  11 +-
 dhall/src/semantics/tck/typecheck.rs   | 187 +++++++++++++++++++++++----------
 dhall/src/tests.rs                     |  15 ++-
 5 files changed, 165 insertions(+), 62 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index 5595c53..850a792 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -83,6 +83,7 @@ pub(crate) enum TypeMessage {
     EquivalenceTypeMismatch(Value, Value),
     AssertMismatch(Value, Value),
     AssertMustTakeEquivalence,
+    Custom(String),
 }
 
 impl TypeError {
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index e848601..066a004 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -625,12 +625,14 @@ pub(crate) fn normalize_one_layer(
         // `RetWhole`), so they won't appear here.
         ExprKind::Lam(_, _, _)
         | ExprKind::Pi(_, _, _)
-        | ExprKind::Let(_, _, _, _)
         | ExprKind::Embed(_)
-        | ExprKind::Var(_)
-        | ExprKind::Annot(_, _) => {
+        | ExprKind::Var(_) => {
             unreachable!("This case should have been handled in typecheck")
         }
+        ExprKind::Let(_, _, val, body) => {
+            Ret::Value(body.subst_shift(&AlphaVar::default(), &val))
+        }
+        ExprKind::Annot(x, _) => Ret::Value(x),
         ExprKind::Const(c) => Ret::Value(const_to_value(c)),
         ExprKind::Builtin(b) => Ret::Value(builtin_to_value(b)),
         ExprKind::Assert(_) => Ret::Expr(expr),
@@ -895,11 +897,16 @@ pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> Value {
                 closure: Closure::new(env, body.clone()),
             }
         }
+        TyExprKind::Expr(ExprKind::Let(_, None, val, body)) => {
+            let val = val.normalize_whnf(env);
+            return body.normalize_whnf(&env.insert_value(val));
+        }
         TyExprKind::Expr(e) => {
             let e = e.map_ref(|tye| tye.normalize_whnf(env));
             normalize_one_layer(e, &ty)
         }
     };
 
+    // dbg!(tye.kind(), env, &kind);
     Value::from_kind_and_type_whnf(kind, ty)
 }
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index f2d1bf2..0f3754e 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -189,7 +189,7 @@ macro_rules! make_type {
     };
 }
 
-fn type_of_builtin<E>(b: Builtin) -> Expr<E> {
+pub(crate) fn type_of_builtin<E>(b: Builtin) -> Expr<E> {
     use syntax::Builtin::*;
     rc(match b {
         Bool | Natural | Integer | Double | Text => make_type!(Type),
@@ -321,7 +321,14 @@ fn type_with(ctx: &TyCtx, e: Expr<Normalized>) -> Result<Value, TypeError> {
 
             let v = type_with(ctx, v)?;
             let binder = ctx.new_binder(x);
-            type_with(&ctx.insert_value(&binder, v.clone())?, e.clone())
+            let e =
+                type_with(&ctx.insert_value(&binder, v.clone())?, e.clone())?;
+            // let e_ty = e.get_type()?;
+            // Ok(Value::from_kind_and_type(
+            //     ValueKind::PartialExpr(ExprKind::Let(x.clone(), None, v, e)),
+            //     e_ty,
+            // ))
+            Ok(e)
         }
         Embed(p) => Ok(p.clone().into_typed().into_value()),
         Var(var) => match ctx.lookup(&var) {
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index aab5f83..046c999 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -10,6 +10,9 @@ use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::context::TyCtx;
 use crate::semantics::nze::{NameEnv, QuoteEnv};
 use crate::semantics::phase::normalize::{merge_maps, NzEnv};
+use crate::semantics::phase::typecheck::{
+    builtin_to_value, const_to_value, type_of_builtin,
+};
 use crate::semantics::phase::Normalized;
 use crate::semantics::{
     AlphaVar, Binder, Closure, TyExpr, TyExprKind, Type, Value, ValueKind,
@@ -55,93 +58,171 @@ impl TyEnv {
             items: self.items.insert_value(e),
         }
     }
-    pub fn lookup_var(&self, var: &V<Label>) -> Option<(TyExprKind, Value)> {
+    pub fn lookup(&self, var: &V<Label>) -> Option<(TyExprKind, Value)> {
         let var = self.names.unlabel_var(var)?;
-        let ty = self.lookup_val(&var).get_type().unwrap();
+        let ty = self.items.lookup_val(&var).get_type().unwrap();
         Some((TyExprKind::Var(var), ty))
     }
-    pub fn lookup_val(&self, var: &AlphaVar) -> Value {
-        self.items.lookup_val(var)
-    }
     pub fn size(&self) -> usize {
         self.names.size()
     }
 }
 
+fn mkerr<T>(x: impl ToString) -> Result<T, TypeError> {
+    Err(TypeError::new(TypeMessage::Custom(x.to_string())))
+}
+
+fn type_last_layer(
+    env: &TyEnv,
+    kind: &ExprKind<TyExpr, Normalized>,
+) -> Result<Value, TypeError> {
+    Ok(match &kind {
+        ExprKind::Import(..) => unreachable!(
+            "There should remain no imports in a resolved expression"
+        ),
+        ExprKind::Var(..)
+        | ExprKind::Lam(..)
+        | ExprKind::Pi(..)
+        | ExprKind::Let(..)
+        | ExprKind::Const(Const::Sort)
+        | ExprKind::Embed(..) => unreachable!(),
+
+        ExprKind::Const(Const::Type) => const_to_value(Const::Kind),
+        ExprKind::Const(Const::Kind) => const_to_value(Const::Sort),
+        ExprKind::Builtin(b) => {
+            type_with(env, &type_of_builtin(*b))?.normalize_whnf(env.as_nzenv())
+        }
+        ExprKind::BoolLit(_) => builtin_to_value(Builtin::Bool),
+        ExprKind::NaturalLit(_) => builtin_to_value(Builtin::Natural),
+        ExprKind::IntegerLit(_) => builtin_to_value(Builtin::Integer),
+        ExprKind::DoubleLit(_) => builtin_to_value(Builtin::Double),
+
+        ExprKind::Annot(x, t) => {
+            if x.get_type()? != t.normalize_whnf(env.as_nzenv()) {
+                return mkerr("annot mismatch");
+            }
+            x.normalize_whnf(env.as_nzenv())
+        }
+        ExprKind::App(f, arg) => {
+            let tf = f.get_type()?;
+            let tf_borrow = tf.as_whnf();
+            let (expected_arg_ty, ty_closure) = match &*tf_borrow {
+                ValueKind::PiClosure { annot, closure, .. } => (annot, closure),
+                _ => return mkerr(format!("apply to not Pi: {:?}", tf_borrow)),
+            };
+            // if arg.get_type()? != *expected_arg_ty {
+            //     return mkerr(format!(
+            //         "function annot mismatch: {:?}, {:?}",
+            //         arg.get_type()?,
+            //         expected_arg_ty
+            //     ));
+            // }
+
+            let arg_nf = arg.normalize_whnf(env.as_nzenv());
+            ty_closure.apply(arg_nf)
+        }
+        ExprKind::BoolIf(x, y, z) => {
+            if *x.get_type()?.as_whnf()
+                != ValueKind::from_builtin(Builtin::Bool)
+            {
+                return mkerr("InvalidPredicate");
+            }
+            if y.get_type()?.get_type()?.as_const() != Some(Const::Type) {
+                return mkerr("IfBranchMustBeTerm");
+            }
+            if z.get_type()?.get_type()?.as_const() != Some(Const::Type) {
+                return mkerr("IfBranchMustBeTerm");
+            }
+            if y.get_type()? != z.get_type()? {
+                return mkerr("IfBranchMismatch");
+            }
+
+            y.get_type()?
+        }
+
+        _ => Value::from_const(Const::Type), // TODO
+    })
+}
+
 /// Type-check an expression and return the expression alongside its type if type-checking
 /// succeeded, or an error if type-checking failed.
-fn type_with(env: &TyEnv, expr: Expr<Normalized>) -> Result<TyExpr, TypeError> {
-    let mkerr = || TypeError::new(TypeMessage::Sort);
-
-    match expr.as_ref() {
-        ExprKind::Var(var) => match env.lookup_var(&var) {
-            Some((e, ty)) => Ok(TyExpr::new(e, Some(ty), expr.span())),
-            None => Err(mkerr()),
+fn type_with(
+    env: &TyEnv,
+    expr: &Expr<Normalized>,
+) -> Result<TyExpr, TypeError> {
+    let (tyekind, ty) = match expr.as_ref() {
+        ExprKind::Var(var) => match env.lookup(&var) {
+            Some((k, ty)) => (k, Some(ty)),
+            None => return mkerr("unbound variable"),
         },
         ExprKind::Lam(binder, annot, body) => {
-            let annot = type_with(env, annot.clone())?;
+            let annot = type_with(env, annot)?;
             let annot_nf = annot.normalize_whnf(env.as_nzenv());
-            let body = type_with(
-                &env.insert_type(&binder, annot_nf.clone()),
-                body.clone(),
-            )?;
+            let body =
+                type_with(&env.insert_type(&binder, annot_nf.clone()), body)?;
             let ty = Value::from_kind_and_type(
                 ValueKind::PiClosure {
                     binder: Binder::new(binder.clone()),
                     annot: annot_nf,
                     closure: Closure::new(
                         env.as_nzenv(),
-                        body.get_type()?.to_tyexpr(env.as_quoteenv()),
+                        body.get_type()?.to_tyexpr(env.as_quoteenv().insert()),
                     ),
                 },
                 Value::from_const(Const::Type), // TODO: function_check
             );
-            Ok(TyExpr::new(
+            (
                 TyExprKind::Expr(ExprKind::Lam(binder.clone(), annot, body)),
                 Some(ty),
-                expr.span(),
-            ))
+            )
         }
         ExprKind::Pi(binder, annot, body) => {
-            let annot = type_with(env, annot.clone())?;
+            let annot = type_with(env, annot)?;
             let annot_nf = annot.normalize_whnf(env.as_nzenv());
-            let body = type_with(
-                &env.insert_type(binder, annot_nf.clone()),
-                body.clone(),
-            )?;
-            Ok(TyExpr::new(
+            let body =
+                type_with(&env.insert_type(binder, annot_nf.clone()), body)?;
+            (
                 TyExprKind::Expr(ExprKind::Pi(binder.clone(), annot, body)),
-                None, // TODO: function_check
-                expr.span(),
-            ))
+                Some(Value::from_const(Const::Type)), // TODO: function_check
+            )
         }
-        kind => {
-            let kind = kind.traverse_ref(|e| type_with(env, e.clone()))?;
-            let ty = match &kind {
-                ExprKind::App(f, arg) => {
-                    let tf = f.get_type()?;
-                    let tf_borrow = tf.as_whnf();
-                    let (_expected_arg_ty, ty_closure) = match &*tf_borrow {
-                        ValueKind::PiClosure { annot, closure, .. } => {
-                            (annot, closure)
-                        }
-                        _ => return Err(mkerr()),
-                    };
-                    // if arg.get_type()? != *expected_arg_ty {
-                    //     return Err(mkerr());
-                    // }
-
-                    let arg_nf = arg.normalize_whnf(env.as_nzenv());
-                    ty_closure.apply(arg_nf)
-                }
-                _ => Value::from_const(Const::Type), // TODO
+        ExprKind::Let(binder, annot, val, body) => {
+            let v = if let Some(t) = annot {
+                t.rewrap(ExprKind::Annot(val.clone(), t.clone()))
+            } else {
+                val.clone()
             };
 
-            Ok(TyExpr::new(TyExprKind::Expr(kind), Some(ty), expr.span()))
+            let val = type_with(env, val)?;
+            let val_nf = val.normalize_whnf(&env.as_nzenv());
+            let body = type_with(&env.insert_value(&binder, val_nf), body)?;
+            let body_ty = body.get_type().ok();
+            (
+                TyExprKind::Expr(ExprKind::Let(
+                    binder.clone(),
+                    None,
+                    val,
+                    body,
+                )),
+                body_ty,
+            )
         }
-    }
+        ExprKind::Const(Const::Sort) => {
+            (TyExprKind::Expr(ExprKind::Const(Const::Sort)), None)
+        }
+        ExprKind::Embed(p) => {
+            return Ok(p.clone().into_typed().into_value().to_tyexpr_noenv())
+        }
+        ekind => {
+            let ekind = ekind.traverse_ref(|e| type_with(env, e))?;
+            let ty = type_last_layer(env, &ekind)?;
+            (TyExprKind::Expr(ekind), Some(ty))
+        }
+    };
+
+    Ok(TyExpr::new(tyekind, ty, expr.span()))
 }
 
-pub(crate) fn typecheck(e: Expr<Normalized>) -> Result<TyExpr, TypeError> {
+pub(crate) fn typecheck(e: &Expr<Normalized>) -> Result<TyExpr, TypeError> {
     type_with(&TyEnv::new(), e)
 }
diff --git a/dhall/src/tests.rs b/dhall/src/tests.rs
index 994a134..f51f6a8 100644
--- a/dhall/src/tests.rs
+++ b/dhall/src/tests.rs
@@ -158,12 +158,19 @@ pub fn run_test(test: Test<'_>) -> Result<()> {
             parse_file_str(&file_path)?.resolve().unwrap_err();
         }
         TypeInferenceSuccess(expr_file_path, expected_file_path) => {
-            let expr =
-                parse_file_str(&expr_file_path)?.resolve()?.typecheck()?;
-            let ty = expr.get_type()?.to_expr();
+            // let expr =
+            //     parse_file_str(&expr_file_path)?.resolve()?.typecheck()?;
+            // let ty = expr.get_type()?.to_expr();
             // let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
             // let tyexpr = crate::semantics::nze::nzexpr::typecheck(expr)?;
             // let ty = tyexpr.get_type()?.to_expr();
+            let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
+            let ty = crate::semantics::tck::typecheck::typecheck(&expr)?
+                .get_type()?
+                .to_expr(crate::semantics::phase::ToExprOptions {
+                    alpha: false,
+                    normalize: true,
+                });
             let expected = parse_file_str(&expected_file_path)?.to_expr();
             assert_eq_display!(ty, expected);
         }
@@ -226,7 +233,7 @@ pub fn run_test(test: Test<'_>) -> Result<()> {
             //         normalize: true,
             //     });
             let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
-            let expr = crate::semantics::tck::typecheck::typecheck(expr)?
+            let expr = crate::semantics::tck::typecheck::typecheck(&expr)?
                 .normalize_whnf_noenv()
                 .to_expr(crate::semantics::phase::ToExprOptions {
                     alpha: false,
-- 
cgit v1.2.3


From f2e8c414993d5c9fcc63f5c035f755712c01dad0 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 25 Jan 2020 10:20:53 +0000
Subject: Enable comparing Closures for equality

---
 dhall/src/semantics/core/value.rs      | 20 +++++++++++---------
 dhall/src/semantics/phase/normalize.rs | 11 +++++++----
 dhall/src/semantics/tck/typecheck.rs   |  3 ++-
 3 files changed, 20 insertions(+), 14 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 11d8bd8..a19cb02 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -55,6 +55,7 @@ pub(crate) enum Form {
 
 #[derive(Debug, Clone)]
 pub(crate) struct Closure {
+    arg_ty: Value,
     env: NzEnv,
     body: TyExpr,
 }
@@ -302,7 +303,7 @@ impl Value {
             } => TyExprKind::Expr(ExprKind::Lam(
                 binder.to_label(),
                 annot.to_tyexpr(qenv),
-                closure.apply_ty(annot.clone()).to_tyexpr(qenv.insert()),
+                closure.normalize().to_tyexpr(qenv.insert()),
             )),
             ValueKind::PiClosure {
                 binder,
@@ -311,7 +312,7 @@ impl Value {
             } => TyExprKind::Expr(ExprKind::Pi(
                 binder.to_label(),
                 annot.to_tyexpr(qenv),
-                closure.apply_ty(annot.clone()).to_tyexpr(qenv.insert()),
+                closure.normalize().to_tyexpr(qenv.insert()),
             )),
             ValueKind::AppliedBuiltin(b, args, types) => {
                 TyExprKind::Expr(args.into_iter().zip(types.into_iter()).fold(
@@ -681,17 +682,19 @@ impl<V> ValueKind<V> {
 }
 
 impl Closure {
-    pub fn new(env: &NzEnv, body: TyExpr) -> Self {
+    pub fn new(arg_ty: Value, env: &NzEnv, body: TyExpr) -> Self {
         Closure {
+            arg_ty,
             env: env.clone(),
-            body: body,
+            body,
         }
     }
     pub fn apply(&self, val: Value) -> Value {
         self.body.normalize_whnf(&self.env.insert_value(val))
     }
-    pub fn apply_ty(&self, ty: Value) -> Value {
-        self.body.normalize_whnf(&self.env.insert_type(ty))
+    pub fn normalize(&self) -> Value {
+        self.body
+            .normalize_whnf(&self.env.insert_type(self.arg_ty.clone()))
     }
 }
 
@@ -703,10 +706,9 @@ impl std::cmp::PartialEq for Value {
 }
 impl std::cmp::Eq for Value {}
 
-// TODO: panics
 impl std::cmp::PartialEq for Closure {
-    fn eq(&self, _other: &Self) -> bool {
-        panic!("comparing closures for equality seems like a bad idea")
+    fn eq(&self, other: &Self) -> bool {
+        self.normalize() == other.normalize()
     }
 }
 impl std::cmp::Eq for Closure {}
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index 066a004..7f547d7 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -884,17 +884,20 @@ pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> Value {
     let kind = match tye.kind() {
         TyExprKind::Var(var) => return env.lookup_val(var),
         TyExprKind::Expr(ExprKind::Lam(binder, annot, body)) => {
+            let annot = annot.normalize_whnf(env);
             ValueKind::LamClosure {
                 binder: Binder::new(binder.clone()),
-                annot: annot.normalize_whnf(env),
-                closure: Closure::new(env, body.clone()),
+                annot: annot.clone(),
+                closure: Closure::new(annot, env, body.clone()),
             }
         }
         TyExprKind::Expr(ExprKind::Pi(binder, annot, body)) => {
+            let annot = annot.normalize_whnf(env);
+            let closure = Closure::new(annot.clone(), env, body.clone());
             ValueKind::PiClosure {
                 binder: Binder::new(binder.clone()),
-                annot: annot.normalize_whnf(env),
-                closure: Closure::new(env, body.clone()),
+                annot,
+                closure,
             }
         }
         TyExprKind::Expr(ExprKind::Let(_, None, val, body)) => {
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index 046c999..52c7ac7 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -163,8 +163,9 @@ fn type_with(
             let ty = Value::from_kind_and_type(
                 ValueKind::PiClosure {
                     binder: Binder::new(binder.clone()),
-                    annot: annot_nf,
+                    annot: annot_nf.clone(),
                     closure: Closure::new(
+                        annot_nf,
                         env.as_nzenv(),
                         body.get_type()?.to_tyexpr(env.as_quoteenv().insert()),
                     ),
-- 
cgit v1.2.3


From 8c64ae33149db4edaaa89d2d187baf10a2b9f8bf Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 25 Jan 2020 13:29:27 +0000
Subject: Make most type errors stringy

---
 dhall/src/error/mod.rs                             |  95 ++++++-------
 dhall/src/semantics/phase/typecheck.rs             | 151 ++++++++-------------
 dhall/tests/type-errors/hurkensParadox.txt         |   9 +-
 .../unit/AnnotationRecordWrongFieldName.txt        |   2 +-
 .../unit/AnnotationRecordWrongFieldType.txt        |   2 +-
 dhall/tests/type-errors/unit/AssertDoubleZeros.txt |   2 +-
 .../type-errors/unit/AssertTriviallyFalse.txt      |   2 +-
 .../type-errors/unit/EquivalenceNotSameType.txt    |   2 +-
 .../tests/type-errors/unit/EquivalenceNotTerms.txt |   2 +-
 .../unit/FunctionApplicationArgumentNotMatch.txt   |  14 +-
 .../unit/FunctionApplicationIsNotFunction.txt      |   7 +-
 .../tests/type-errors/unit/IfBranchesNotMatch.txt  |   2 +-
 dhall/tests/type-errors/unit/IfBranchesNotType.txt |   2 +-
 dhall/tests/type-errors/unit/IfNotBool.txt         |   2 +-
 .../type-errors/unit/LetWithWrongAnnotation.txt    |   2 +-
 .../type-errors/unit/ListLiteralEmptyNotType.txt   |  14 +-
 .../tests/type-errors/unit/ListLiteralNotType.txt  |   2 +-
 .../type-errors/unit/ListLiteralTypesNotMatch.txt  |   2 +-
 .../unit/MergeAlternativeHasNoHandler.txt          |   2 +-
 .../type-errors/unit/MergeAnnotationNotType.txt    |   2 +-
 .../unit/MergeEmptyWithoutAnnotation.txt           |   2 +-
 .../type-errors/unit/MergeHandlerNotFunction.txt   |   2 +-
 .../type-errors/unit/MergeHandlerNotInUnion.txt    |   2 +-
 .../unit/MergeHandlerNotMatchAlternativeType.txt   |  14 +-
 dhall/tests/type-errors/unit/MergeLhsNotRecord.txt |   2 +-
 .../type-errors/unit/MergeMissingHandler1.txt      |   2 +-
 .../type-errors/unit/MergeMissingHandler2.txt      |   2 +-
 dhall/tests/type-errors/unit/MergeRhsNotUnion.txt  |   2 +-
 .../tests/type-errors/unit/MergeUnusedHandler.txt  |   2 +-
 .../type-errors/unit/NaturalSubtractNotNatural.txt |  14 +-
 .../tests/type-errors/unit/OperatorAndNotBool.txt  |   2 +-
 .../type-errors/unit/OperatorEqualNotBool.txt      |   2 +-
 .../unit/OperatorListConcatenateLhsNotList.txt     |   2 +-
 .../unit/OperatorListConcatenateListsNotMatch.txt  |   2 +-
 .../OperatorListConcatenateNotListsButMatch.txt    |   2 +-
 .../unit/OperatorListConcatenateRhsNotList.txt     |   2 +-
 .../type-errors/unit/OperatorNotEqualNotBool.txt   |   2 +-
 dhall/tests/type-errors/unit/OperatorOrNotBool.txt |   2 +-
 .../type-errors/unit/OperatorPlusNotNatural.txt    |   2 +-
 .../unit/OperatorTextConcatenateLhsNotText.txt     |   2 +-
 .../unit/OperatorTextConcatenateRhsNotText.txt     |   2 +-
 .../type-errors/unit/OperatorTimesNotNatural.txt   |   2 +-
 .../unit/OptionalDeprecatedSyntaxAbsent.txt        |   2 +-
 .../unit/OptionalDeprecatedSyntaxPresent.txt       |   2 +-
 .../type-errors/unit/RecordSelectionEmpty.txt      |   2 +-
 .../type-errors/unit/RecordSelectionNotPresent.txt |   2 +-
 .../type-errors/unit/RecordSelectionNotRecord.txt  |   2 +-
 .../unit/RecordSelectionTypeNotUnionType.txt       |   2 +-
 .../unit/RecursiveRecordMergeLhsNotRecord.txt      |   2 +-
 .../unit/RecursiveRecordMergeOverlapping.txt       |   2 +-
 .../unit/RecursiveRecordMergeRhsNotRecord.txt      |   2 +-
 .../RecursiveRecordTypeMergeLhsNotRecordType.txt   |   2 +-
 .../unit/RecursiveRecordTypeMergeOverlapping.txt   |   2 +-
 .../RecursiveRecordTypeMergeRhsNotRecordType.txt   |   2 +-
 .../unit/RightBiasedRecordMergeLhsNotRecord.txt    |   2 +-
 .../unit/RightBiasedRecordMergeRhsNotRecord.txt    |   2 +-
 dhall/tests/type-errors/unit/SomeNotType.txt       |   2 +-
 .../unit/TextLiteralInterpolateNotText.txt         |   2 +-
 .../tests/type-errors/unit/TypeAnnotationWrong.txt |   2 +-
 .../unit/UnionConstructorFieldNotPresent.txt       |   2 +-
 60 files changed, 159 insertions(+), 263 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index 850a792..5330c59 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -3,7 +3,7 @@ use std::io::Error as IOError;
 use crate::semantics::core::value::Value;
 use crate::semantics::phase::resolve::ImportStack;
 use crate::semantics::phase::NormalizedExpr;
-use crate::syntax::{BinOp, Import, Label, ParseError, Span};
+use crate::syntax::{Import, Label, ParseError, Span};
 
 pub type Result<T> = std::result::Result<T, Error>;
 
@@ -48,41 +48,41 @@ pub(crate) enum TypeMessage {
     UnboundVariable(Span),
     InvalidInputType(Value),
     InvalidOutputType(Value),
-    NotAFunction(Value),
-    TypeMismatch(Value, Value, Value),
-    AnnotMismatch(Value, Value),
-    InvalidListElement(usize, Value, Value),
-    InvalidListType(Value),
-    InvalidOptionalType(Value),
-    InvalidPredicate(Value),
-    IfBranchMismatch(Value, Value),
-    IfBranchMustBeTerm(bool, Value),
+    // NotAFunction(Value),
+    // TypeMismatch(Value, Value, Value),
+    // AnnotMismatch(Value, Value),
+    // InvalidListElement(usize, Value, Value),
+    // InvalidListType(Value),
+    // InvalidOptionalType(Value),
+    // InvalidPredicate(Value),
+    // IfBranchMismatch(Value, Value),
+    // IfBranchMustBeTerm(bool, Value),
     InvalidFieldType(Label, Value),
-    NotARecord(Label, Value),
-    MustCombineRecord(Value),
-    MissingRecordField(Label, Value),
-    MissingUnionField(Label, Value),
-    BinOpTypeMismatch(BinOp, Value),
-    InvalidTextInterpolation(Value),
-    Merge1ArgMustBeRecord(Value),
-    Merge2ArgMustBeUnionOrOptional(Value),
-    MergeEmptyNeedsAnnotation,
-    MergeHandlerMissingVariant(Label),
-    MergeVariantMissingHandler(Label),
-    MergeAnnotMismatch,
-    MergeHandlerTypeMismatch,
-    MergeHandlerReturnTypeMustNotBeDependent,
-    ProjectionMustBeRecord,
-    ProjectionMissingEntry,
-    ProjectionDuplicateField,
+    // NotARecord(Label, Value),
+    // MustCombineRecord(Value),
+    // MissingRecordField(Label, Value),
+    // MissingUnionField(Label, Value),
+    // BinOpTypeMismatch(BinOp, Value),
+    // InvalidTextInterpolation(Value),
+    // Merge1ArgMustBeRecord(Value),
+    // Merge2ArgMustBeUnionOrOptional(Value),
+    // MergeEmptyNeedsAnnotation,
+    // MergeHandlerMissingVariant(Label),
+    // MergeVariantMissingHandler(Label),
+    // MergeAnnotMismatch,
+    // MergeHandlerTypeMismatch,
+    // MergeHandlerReturnTypeMustNotBeDependent,
+    // ProjectionMustBeRecord,
+    // ProjectionMissingEntry,
+    // ProjectionDuplicateField,
     Sort,
     RecordTypeDuplicateField,
-    RecordTypeMergeRequiresRecordType(Value),
+    // RecordTypeMergeRequiresRecordType(Value),
     UnionTypeDuplicateField,
-    EquivalenceArgumentMustBeTerm(bool, Value),
-    EquivalenceTypeMismatch(Value, Value),
-    AssertMismatch(Value, Value),
-    AssertMustTakeEquivalence,
+    // EquivalenceArgumentMustBeTerm(bool, Value),
+    // EquivalenceTypeMismatch(Value, Value),
+    // AssertMismatch(Value, Value),
+    // AssertMustTakeEquivalence,
     Custom(String),
 }
 
@@ -103,21 +103,22 @@ impl std::fmt::Display for TypeError {
             InvalidOutputType(v) => {
                 v.span().error("Type error: Invalid function output")
             }
-            NotAFunction(v) => v.span().error("Type error: Not a function"),
-            TypeMismatch(x, y, z) => {
-                x.span()
-                    .error("Type error: Wrong type of function argument")
-                    + "\n"
-                    + &z.span().error(format!(
-                        "This argument has type {:?}",
-                        z.get_type().unwrap()
-                    ))
-                    + "\n"
-                    + &y.span().error(format!(
-                        "But the function expected an argument of type {:?}",
-                        y
-                    ))
-            }
+            // NotAFunction(v) => v.span().error("Type error: Not a function"),
+            // TypeMismatch(x, y, z) => {
+            //     x.span()
+            //         .error("Type error: Wrong type of function argument")
+            //         + "\n"
+            //         + &z.span().error(format!(
+            //             "This argument has type {:?}",
+            //             z.get_type().unwrap()
+            //         ))
+            //         + "\n"
+            //         + &y.span().error(format!(
+            //             "But the function expected an argument of type {:?}",
+            //             y
+            //         ))
+            // }
+            Custom(s) => format!("Type error: Unhandled error: {}", s),
             _ => format!("Type error: Unhandled error: {:?}", self.message),
         };
         write!(f, "{}", msg)
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index 0f3754e..44678cd 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -357,8 +357,8 @@ fn type_last_layer(
     use syntax::Builtin::*;
     use syntax::Const::Type;
     use syntax::ExprKind::*;
-    use TypeMessage::*;
-    let mkerr = |msg: TypeMessage| Err(TypeError::new(msg));
+    let mkerr =
+        |msg: &str| Err(TypeError::new(TypeMessage::Custom(msg.to_string())));
 
     /// Intermediary return type
     enum Ret {
@@ -381,10 +381,10 @@ fn type_last_layer(
             let tf_borrow = tf.as_whnf();
             let (tx, tb) = match &*tf_borrow {
                 ValueKind::Pi(_, tx, tb) => (tx, tb),
-                _ => return mkerr(NotAFunction(f.clone())),
+                _ => return mkerr("NotAFunction"),
             };
             if &a.get_type()? != tx {
-                return mkerr(TypeMismatch(f.clone(), tx.clone(), a.clone()));
+                return mkerr("TypeMismatch");
             }
 
             let ret = tb.subst_shift(&AlphaVar::default(), a);
@@ -393,35 +393,33 @@ fn type_last_layer(
         }
         Annot(x, t) => {
             if &x.get_type()? != t {
-                return mkerr(AnnotMismatch(x.clone(), t.clone()));
+                return mkerr("AnnotMismatch");
             }
             RetWhole(x.clone())
         }
         Assert(t) => {
             match &*t.as_whnf() {
                 ValueKind::Equivalence(x, y) if x == y => {}
-                ValueKind::Equivalence(x, y) => {
-                    return mkerr(AssertMismatch(x.clone(), y.clone()))
-                }
-                _ => return mkerr(AssertMustTakeEquivalence),
+                ValueKind::Equivalence(..) => return mkerr("AssertMismatch"),
+                _ => return mkerr("AssertMustTakeEquivalence"),
             }
             RetTypeOnly(t.clone())
         }
         BoolIf(x, y, z) => {
             if *x.get_type()?.as_whnf() != ValueKind::from_builtin(Bool) {
-                return mkerr(InvalidPredicate(x.clone()));
+                return mkerr("InvalidPredicate");
             }
 
             if y.get_type()?.get_type()?.as_const() != Some(Type) {
-                return mkerr(IfBranchMustBeTerm(true, y.clone()));
+                return mkerr("IfBranchMustBeTerm");
             }
 
             if z.get_type()?.get_type()?.as_const() != Some(Type) {
-                return mkerr(IfBranchMustBeTerm(false, z.clone()));
+                return mkerr("IfBranchMustBeTerm");
             }
 
             if y.get_type()? != z.get_type()? {
-                return mkerr(IfBranchMismatch(y.clone(), z.clone()));
+                return mkerr("IfBranchMismatch");
             }
 
             RetTypeOnly(y.get_type()?)
@@ -433,7 +431,7 @@ fn type_last_layer(
                 {
                     args[0].clone()
                 }
-                _ => return mkerr(InvalidListType(t.clone())),
+                _ => return mkerr("InvalidListType"),
             };
             RetWhole(Value::from_kind_and_type(
                 ValueKind::EmptyListLit(arg),
@@ -443,18 +441,14 @@ fn type_last_layer(
         NEListLit(xs) => {
             let mut iter = xs.iter().enumerate();
             let (_, x) = iter.next().unwrap();
-            for (i, y) in iter {
+            for (_, y) in iter {
                 if x.get_type()? != y.get_type()? {
-                    return mkerr(InvalidListElement(
-                        i,
-                        x.get_type()?,
-                        y.clone(),
-                    ));
+                    return mkerr("InvalidListElement");
                 }
             }
             let t = x.get_type()?;
             if t.get_type()?.as_const() != Some(Type) {
-                return mkerr(InvalidListType(t));
+                return mkerr("InvalidListType");
             }
 
             RetTypeOnly(Value::from_builtin(syntax::Builtin::List).app(t))
@@ -462,7 +456,7 @@ fn type_last_layer(
         SomeLit(x) => {
             let t = x.get_type()?;
             if t.get_type()?.as_const() != Some(Type) {
-                return mkerr(InvalidOptionalType(t));
+                return mkerr("InvalidOptionalType");
             }
 
             RetTypeOnly(Value::from_builtin(syntax::Builtin::Optional).app(t))
@@ -479,48 +473,25 @@ fn type_last_layer(
         Field(r, x) => {
             match &*r.get_type()?.as_whnf() {
                 ValueKind::RecordType(kts) => match kts.get(&x) {
-                    Some(tth) => {
-                        RetTypeOnly(tth.clone())
-                    },
-                    None => return mkerr(MissingRecordField(x.clone(),
-                                        r.clone())),
+                    Some(tth) => RetTypeOnly(tth.clone()),
+                    None => return mkerr("MissingRecordField"),
                 },
                 // TODO: branch here only when r.get_type() is a Const
                 _ => {
                     match &*r.as_whnf() {
                         ValueKind::UnionType(kts) => match kts.get(&x) {
                             // Constructor has type T -> < x: T, ... >
-                            Some(Some(t)) => {
-                                RetTypeOnly(
-                                    tck_pi_type(
-                                        ctx.new_binder(x),
-                                        t.clone(),
-                                        r.under_binder(),
-                                    )?
-                                )
-                            },
-                            Some(None) => {
-                                RetTypeOnly(r.clone())
-                            },
-                            None => {
-                                return mkerr(MissingUnionField(
-                                    x.clone(),
-                                    r.clone(),
-                                ))
-                            },
-                        },
-                        _ => {
-                            return mkerr(NotARecord(
-                                x.clone(),
-                                r.clone()
-                            ))
+                            Some(Some(t)) => RetTypeOnly(tck_pi_type(
+                                ctx.new_binder(x),
+                                t.clone(),
+                                r.under_binder(),
+                            )?),
+                            Some(None) => RetTypeOnly(r.clone()),
+                            None => return mkerr("MissingUnionField"),
                         },
+                        _ => return mkerr("NotARecord"),
                     }
-                }
-                // _ => mkerr(NotARecord(
-                //     x,
-                //     r?,
-                // )),
+                } // _ => mkerr("NotARecord"),
             }
         }
         Const(c) => RetWhole(const_to_value(*c)),
@@ -535,7 +506,7 @@ fn type_last_layer(
                 use InterpolatedTextContents::Expr;
                 if let Expr(x) = contents {
                     if x.get_type()? != text_type {
-                        return mkerr(InvalidTextInterpolation(x.clone()));
+                        return mkerr("InvalidTextInterpolation");
                     }
                 }
             }
@@ -549,14 +520,14 @@ fn type_last_layer(
             let l_type_borrow = l_type.as_whnf();
             let kts_x = match &*l_type_borrow {
                 ValueKind::RecordType(kts) => kts,
-                _ => return mkerr(MustCombineRecord(l.clone())),
+                _ => return mkerr("MustCombineRecord"),
             };
 
             // Extract the RHS record type
             let r_type_borrow = r_type.as_whnf();
             let kts_y = match &*r_type_borrow {
                 ValueKind::RecordType(kts) => kts,
-                _ => return mkerr(MustCombineRecord(r.clone())),
+                _ => return mkerr("MustCombineRecord"),
             };
 
             // Union the two records, prefering
@@ -584,18 +555,14 @@ fn type_last_layer(
             let borrow_l = l.as_whnf();
             let kts_x = match &*borrow_l {
                 ValueKind::RecordType(kts) => kts,
-                _ => {
-                    return mkerr(RecordTypeMergeRequiresRecordType(l.clone()))
-                }
+                _ => return mkerr("RecordTypeMergeRequiresRecordType"),
             };
 
             // Extract the RHS record type
             let borrow_r = r.as_whnf();
             let kts_y = match &*borrow_r {
                 ValueKind::RecordType(kts) => kts,
-                _ => {
-                    return mkerr(RecordTypeMergeRequiresRecordType(r.clone()))
-                }
+                _ => return mkerr("RecordTypeMergeRequiresRecordType"),
             };
 
             // Ensure that the records combine without a type error
@@ -618,28 +585,28 @@ fn type_last_layer(
 
             RetWhole(tck_record_type(kts.into_iter().map(Ok))?)
         }
-        BinOp(o @ ListAppend, l, r) => {
+        BinOp(ListAppend, l, r) => {
             match &*l.get_type()?.as_whnf() {
                 ValueKind::AppliedBuiltin(List, _, _) => {}
-                _ => return mkerr(BinOpTypeMismatch(*o, l.clone())),
+                _ => return mkerr("BinOpTypeMismatch"),
             }
 
             if l.get_type()? != r.get_type()? {
-                return mkerr(BinOpTypeMismatch(*o, r.clone()));
+                return mkerr("BinOpTypeMismatch");
             }
 
             RetTypeOnly(l.get_type()?)
         }
         BinOp(Equivalence, l, r) => {
             if l.get_type()?.get_type()?.as_const() != Some(Type) {
-                return mkerr(EquivalenceArgumentMustBeTerm(true, l.clone()));
+                return mkerr("EquivalenceArgumentMustBeTerm");
             }
             if r.get_type()?.get_type()?.as_const() != Some(Type) {
-                return mkerr(EquivalenceArgumentMustBeTerm(false, r.clone()));
+                return mkerr("EquivalenceArgumentMustBeTerm");
             }
 
             if l.get_type()? != r.get_type()? {
-                return mkerr(EquivalenceTypeMismatch(r.clone(), l.clone()));
+                return mkerr("EquivalenceTypeMismatch");
             }
 
             RetWhole(Value::from_kind_and_type(
@@ -665,11 +632,11 @@ fn type_last_layer(
             });
 
             if l.get_type()? != t {
-                return mkerr(BinOpTypeMismatch(*o, l.clone()));
+                return mkerr("BinOpTypeMismatch");
             }
 
             if r.get_type()? != t {
-                return mkerr(BinOpTypeMismatch(*o, r.clone()));
+                return mkerr("BinOpTypeMismatch");
             }
 
             RetTypeOnly(t)
@@ -679,7 +646,7 @@ fn type_last_layer(
             let record_borrow = record_type.as_whnf();
             let handlers = match &*record_borrow {
                 ValueKind::RecordType(kts) => kts,
-                _ => return mkerr(Merge1ArgMustBeRecord(record.clone())),
+                _ => return mkerr("Merge1ArgMustBeRecord"),
             };
 
             let union_type = union.get_type()?;
@@ -697,9 +664,7 @@ fn type_last_layer(
                     kts.insert("Some".into(), Some(ty.clone()));
                     Cow::Owned(kts)
                 }
-                _ => {
-                    return mkerr(Merge2ArgMustBeUnionOrOptional(union.clone()))
-                }
+                _ => return mkerr("Merge2ArgMustBeUnionOrOptional"),
             };
 
             let mut inferred_type = None;
@@ -711,19 +676,11 @@ fn type_last_layer(
                             let handler_type_borrow = handler_type.as_whnf();
                             let (tx, tb) = match &*handler_type_borrow {
                                 ValueKind::Pi(_, tx, tb) => (tx, tb),
-                                _ => {
-                                    return mkerr(NotAFunction(
-                                        handler_type.clone(),
-                                    ))
-                                }
+                                _ => return mkerr("NotAFunction"),
                             };
 
                             if variant_type != tx {
-                                return mkerr(TypeMismatch(
-                                    handler_type.clone(),
-                                    tx.clone(),
-                                    variant_type.clone(),
-                                ));
+                                return mkerr("TypeMismatch");
                             }
 
                             // Extract `tb` from under the binder. Fails if the variable was used
@@ -731,41 +688,39 @@ fn type_last_layer(
                             match tb.over_binder() {
                                 Some(x) => x,
                                 None => return mkerr(
-                                    MergeHandlerReturnTypeMustNotBeDependent,
+                                    "MergeHandlerReturnTypeMustNotBeDependent",
                                 ),
                             }
                         }
                         // Union alternative without type
                         Some(None) => handler_type.clone(),
-                        None => {
-                            return mkerr(MergeHandlerMissingVariant(x.clone()))
-                        }
+                        None => return mkerr("MergeHandlerMissingVariant"),
                     };
                 match &inferred_type {
                     None => inferred_type = Some(handler_return_type),
                     Some(t) => {
                         if t != &handler_return_type {
-                            return mkerr(MergeHandlerTypeMismatch);
+                            return mkerr("MergeHandlerTypeMismatch");
                         }
                     }
                 }
             }
             for x in variants.keys() {
                 if !handlers.contains_key(x) {
-                    return mkerr(MergeVariantMissingHandler(x.clone()));
+                    return mkerr("MergeVariantMissingHandler");
                 }
             }
 
             match (inferred_type, type_annot.as_ref()) {
                 (Some(t1), Some(t2)) => {
                     if &t1 != t2 {
-                        return mkerr(MergeAnnotMismatch);
+                        return mkerr("MergeAnnotMismatch");
                     }
                     RetTypeOnly(t1)
                 }
                 (Some(t), None) => RetTypeOnly(t),
                 (None, Some(t)) => RetTypeOnly(t.clone()),
-                (None, None) => return mkerr(MergeEmptyNeedsAnnotation),
+                (None, None) => return mkerr("MergeEmptyNeedsAnnotation"),
             }
         }
         ToMap(_, _) => unimplemented!("toMap"),
@@ -774,18 +729,18 @@ fn type_last_layer(
             let record_type_borrow = record_type.as_whnf();
             let kts = match &*record_type_borrow {
                 ValueKind::RecordType(kts) => kts,
-                _ => return mkerr(ProjectionMustBeRecord),
+                _ => return mkerr("ProjectionMustBeRecord"),
             };
 
             let mut new_kts = HashMap::new();
             for l in labels {
                 match kts.get(l) {
-                    None => return mkerr(ProjectionMissingEntry),
+                    None => return mkerr("ProjectionMissingEntry"),
                     Some(t) => {
                         use std::collections::hash_map::Entry;
                         match new_kts.entry(l.clone()) {
                             Entry::Occupied(_) => {
-                                return mkerr(ProjectionDuplicateField)
+                                return mkerr("ProjectionDuplicateField")
                             }
                             Entry::Vacant(e) => e.insert(t.clone()),
                         }
diff --git a/dhall/tests/type-errors/hurkensParadox.txt b/dhall/tests/type-errors/hurkensParadox.txt
index 870388d..9342fd8 100644
--- a/dhall/tests/type-errors/hurkensParadox.txt
+++ b/dhall/tests/type-errors/hurkensParadox.txt
@@ -1,8 +1 @@
-[unknown location] Type error: Wrong type of function argument
-[unknown location] This argument has type Sort
- --> 5:21
-  |
-5 | in  let pow = λ(X : Kind) → X → Type␊
-  |                     ^--^
-  |
-  = But the function expected an argument of type Kind
+Type error: Unhandled error: TypeMismatch
diff --git a/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldName.txt b/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldName.txt
index 3f737c2..045eb98 100644
--- a/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldName.txt
+++ b/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldName.txt
@@ -1 +1 @@
-Type error: Unhandled error: AnnotMismatch(Value@Unevaled { value: PartialExpr(RecordLit(DupTreeMap { map: {Label("x"): [Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@Unevaled { value: AppliedBuiltin(Natural, [], []), type: Type } }]}, size: 1 })), type: Value@WHNF { value: RecordType({Label("x"): Value@Unevaled { value: AppliedBuiltin(Natural, [], []), type: Type }}), type: Type } }, Value@WHNF { value: RecordType({Label("y"): Value@Unevaled { value: AppliedBuiltin(Natural, [], []), type: Type }}), type: Type })
+Type error: Unhandled error: AnnotMismatch
diff --git a/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldType.txt b/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldType.txt
index d211716..045eb98 100644
--- a/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldType.txt
+++ b/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldType.txt
@@ -1 +1 @@
-Type error: Unhandled error: AnnotMismatch(Value@Unevaled { value: PartialExpr(RecordLit(DupTreeMap { map: {Label("x"): [Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } }]}, size: 1 })), type: Value@WHNF { value: RecordType({Label("x"): Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type }}), type: Type } }, Value@WHNF { value: RecordType({Label("x"): Value@WHNF { value: AppliedBuiltin(Text, [], []), type: Type }}), type: Type })
+Type error: Unhandled error: AnnotMismatch
diff --git a/dhall/tests/type-errors/unit/AssertDoubleZeros.txt b/dhall/tests/type-errors/unit/AssertDoubleZeros.txt
index 6886495..d8627ba 100644
--- a/dhall/tests/type-errors/unit/AssertDoubleZeros.txt
+++ b/dhall/tests/type-errors/unit/AssertDoubleZeros.txt
@@ -1 +1 @@
-Type error: Unhandled error: AssertMismatch(Value@WHNF { value: DoubleLit(NaiveDouble(-0.0)), type: Value@WHNF { value: AppliedBuiltin(Double, [], []), type: Type } }, Value@WHNF { value: DoubleLit(NaiveDouble(0.0)), type: Value@WHNF { value: AppliedBuiltin(Double, [], []), type: Type } })
+Type error: Unhandled error: AssertMismatch
diff --git a/dhall/tests/type-errors/unit/AssertTriviallyFalse.txt b/dhall/tests/type-errors/unit/AssertTriviallyFalse.txt
index 6f8e4a7..d8627ba 100644
--- a/dhall/tests/type-errors/unit/AssertTriviallyFalse.txt
+++ b/dhall/tests/type-errors/unit/AssertTriviallyFalse.txt
@@ -1 +1 @@
-Type error: Unhandled error: AssertMismatch(Value@WHNF { value: NaturalLit(1), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } }, Value@WHNF { value: NaturalLit(2), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
+Type error: Unhandled error: AssertMismatch
diff --git a/dhall/tests/type-errors/unit/EquivalenceNotSameType.txt b/dhall/tests/type-errors/unit/EquivalenceNotSameType.txt
index bdbe0e4..89749e9 100644
--- a/dhall/tests/type-errors/unit/EquivalenceNotSameType.txt
+++ b/dhall/tests/type-errors/unit/EquivalenceNotSameType.txt
@@ -1 +1 @@
-Type error: Unhandled error: EquivalenceTypeMismatch(Value@Unevaled { value: PartialExpr(BoolLit(false)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } }, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
+Type error: Unhandled error: EquivalenceTypeMismatch
diff --git a/dhall/tests/type-errors/unit/EquivalenceNotTerms.txt b/dhall/tests/type-errors/unit/EquivalenceNotTerms.txt
index 23b37d3..7c48d6f 100644
--- a/dhall/tests/type-errors/unit/EquivalenceNotTerms.txt
+++ b/dhall/tests/type-errors/unit/EquivalenceNotTerms.txt
@@ -1 +1 @@
-Type error: Unhandled error: EquivalenceArgumentMustBeTerm(true, Value@Unevaled { value: AppliedBuiltin(Bool, [], []), type: Type })
+Type error: Unhandled error: EquivalenceArgumentMustBeTerm
diff --git a/dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt b/dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt
index 8507ccf..9342fd8 100644
--- a/dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt
+++ b/dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt
@@ -1,13 +1 @@
-[unknown location] Type error: Wrong type of function argument
- --> 1:22
-  |
-1 | (λ(_ : Natural) → _) True␊
-  |                      ^--^
-  |
-  = This argument has type Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type }
- --> 1:8
-  |
-1 | (λ(_ : Natural) → _) True␊
-  |        ^-----^
-  |
-  = But the function expected an argument of type Value@NF { value: AppliedBuiltin(Natural, [], []), type: Type }
+Type error: Unhandled error: TypeMismatch
diff --git a/dhall/tests/type-errors/unit/FunctionApplicationIsNotFunction.txt b/dhall/tests/type-errors/unit/FunctionApplicationIsNotFunction.txt
index 062f9de..f1cdf92 100644
--- a/dhall/tests/type-errors/unit/FunctionApplicationIsNotFunction.txt
+++ b/dhall/tests/type-errors/unit/FunctionApplicationIsNotFunction.txt
@@ -1,6 +1 @@
- --> 1:1
-  |
-1 | True True␊
-  | ^--^
-  |
-  = Type error: Not a function
+Type error: Unhandled error: NotAFunction
diff --git a/dhall/tests/type-errors/unit/IfBranchesNotMatch.txt b/dhall/tests/type-errors/unit/IfBranchesNotMatch.txt
index 4d28695..6b1dcdd 100644
--- a/dhall/tests/type-errors/unit/IfBranchesNotMatch.txt
+++ b/dhall/tests/type-errors/unit/IfBranchesNotMatch.txt
@@ -1 +1 @@
-Type error: Unhandled error: IfBranchMismatch(Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } }, Value@Unevaled { value: PartialExpr(TextLit(InterpolatedText { head: "", tail: [] })), type: Value@WHNF { value: AppliedBuiltin(Text, [], []), type: Type } })
+Type error: Unhandled error: IfBranchMismatch
diff --git a/dhall/tests/type-errors/unit/IfBranchesNotType.txt b/dhall/tests/type-errors/unit/IfBranchesNotType.txt
index 8ef3a40..06039a7 100644
--- a/dhall/tests/type-errors/unit/IfBranchesNotType.txt
+++ b/dhall/tests/type-errors/unit/IfBranchesNotType.txt
@@ -1 +1 @@
-Type error: Unhandled error: IfBranchMustBeTerm(true, Type)
+Type error: Unhandled error: IfBranchMustBeTerm
diff --git a/dhall/tests/type-errors/unit/IfNotBool.txt b/dhall/tests/type-errors/unit/IfNotBool.txt
index 665093f..b2d200c 100644
--- a/dhall/tests/type-errors/unit/IfNotBool.txt
+++ b/dhall/tests/type-errors/unit/IfNotBool.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidPredicate(Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
+Type error: Unhandled error: InvalidPredicate
diff --git a/dhall/tests/type-errors/unit/LetWithWrongAnnotation.txt b/dhall/tests/type-errors/unit/LetWithWrongAnnotation.txt
index 61096d0..045eb98 100644
--- a/dhall/tests/type-errors/unit/LetWithWrongAnnotation.txt
+++ b/dhall/tests/type-errors/unit/LetWithWrongAnnotation.txt
@@ -1 +1 @@
-Type error: Unhandled error: AnnotMismatch(Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } }, Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type })
+Type error: Unhandled error: AnnotMismatch
diff --git a/dhall/tests/type-errors/unit/ListLiteralEmptyNotType.txt b/dhall/tests/type-errors/unit/ListLiteralEmptyNotType.txt
index e075521..9342fd8 100644
--- a/dhall/tests/type-errors/unit/ListLiteralEmptyNotType.txt
+++ b/dhall/tests/type-errors/unit/ListLiteralEmptyNotType.txt
@@ -1,13 +1 @@
- --> 1:6
-  |
-1 | [] : List Type␊
-  |      ^--^
-  |
-  = Type error: Wrong type of function argument
- --> 1:11
-  |
-1 | [] : List Type␊
-  |           ^--^
-  |
-  = This argument has type Kind
-[unknown location] But the function expected an argument of type Type
+Type error: Unhandled error: TypeMismatch
diff --git a/dhall/tests/type-errors/unit/ListLiteralNotType.txt b/dhall/tests/type-errors/unit/ListLiteralNotType.txt
index 99b95a3..3937453 100644
--- a/dhall/tests/type-errors/unit/ListLiteralNotType.txt
+++ b/dhall/tests/type-errors/unit/ListLiteralNotType.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidListType(Type)
+Type error: Unhandled error: InvalidListType
diff --git a/dhall/tests/type-errors/unit/ListLiteralTypesNotMatch.txt b/dhall/tests/type-errors/unit/ListLiteralTypesNotMatch.txt
index 2355b7c..a64cf67 100644
--- a/dhall/tests/type-errors/unit/ListLiteralTypesNotMatch.txt
+++ b/dhall/tests/type-errors/unit/ListLiteralTypesNotMatch.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidListElement(1, Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type }, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
+Type error: Unhandled error: InvalidListElement
diff --git a/dhall/tests/type-errors/unit/MergeAlternativeHasNoHandler.txt b/dhall/tests/type-errors/unit/MergeAlternativeHasNoHandler.txt
index d4e9024..711d77d 100644
--- a/dhall/tests/type-errors/unit/MergeAlternativeHasNoHandler.txt
+++ b/dhall/tests/type-errors/unit/MergeAlternativeHasNoHandler.txt
@@ -1 +1 @@
-Type error: Unhandled error: MergeVariantMissingHandler(Label("x"))
+Type error: Unhandled error: MergeVariantMissingHandler
diff --git a/dhall/tests/type-errors/unit/MergeAnnotationNotType.txt b/dhall/tests/type-errors/unit/MergeAnnotationNotType.txt
index 7da5cb9..4c72653 100644
--- a/dhall/tests/type-errors/unit/MergeAnnotationNotType.txt
+++ b/dhall/tests/type-errors/unit/MergeAnnotationNotType.txt
@@ -1 +1 @@
-Type error: Unhandled error: Merge2ArgMustBeUnionOrOptional(Value@Unevaled { value: UnionType({}), type: Type })
+Type error: Unhandled error: Merge2ArgMustBeUnionOrOptional
diff --git a/dhall/tests/type-errors/unit/MergeEmptyWithoutAnnotation.txt b/dhall/tests/type-errors/unit/MergeEmptyWithoutAnnotation.txt
index 7da5cb9..4c72653 100644
--- a/dhall/tests/type-errors/unit/MergeEmptyWithoutAnnotation.txt
+++ b/dhall/tests/type-errors/unit/MergeEmptyWithoutAnnotation.txt
@@ -1 +1 @@
-Type error: Unhandled error: Merge2ArgMustBeUnionOrOptional(Value@Unevaled { value: UnionType({}), type: Type })
+Type error: Unhandled error: Merge2ArgMustBeUnionOrOptional
diff --git a/dhall/tests/type-errors/unit/MergeHandlerNotFunction.txt b/dhall/tests/type-errors/unit/MergeHandlerNotFunction.txt
index c5ed223..f1cdf92 100644
--- a/dhall/tests/type-errors/unit/MergeHandlerNotFunction.txt
+++ b/dhall/tests/type-errors/unit/MergeHandlerNotFunction.txt
@@ -1 +1 @@
-[unknown location] Type error: Not a function
+Type error: Unhandled error: NotAFunction
diff --git a/dhall/tests/type-errors/unit/MergeHandlerNotInUnion.txt b/dhall/tests/type-errors/unit/MergeHandlerNotInUnion.txt
index 7da5cb9..4c72653 100644
--- a/dhall/tests/type-errors/unit/MergeHandlerNotInUnion.txt
+++ b/dhall/tests/type-errors/unit/MergeHandlerNotInUnion.txt
@@ -1 +1 @@
-Type error: Unhandled error: Merge2ArgMustBeUnionOrOptional(Value@Unevaled { value: UnionType({}), type: Type })
+Type error: Unhandled error: Merge2ArgMustBeUnionOrOptional
diff --git a/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt b/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt
index 19f375a..9342fd8 100644
--- a/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt
+++ b/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt
@@ -1,13 +1 @@
-[unknown location] Type error: Wrong type of function argument
- --> 1:38
-  |
-1 | merge { x = λ(_ : Bool) → _ } (< x : Natural >.x 1)␊
-  |                                      ^-----^
-  |
-  = This argument has type Type
- --> 1:19
-  |
-1 | merge { x = λ(_ : Bool) → _ } (< x : Natural >.x 1)␊
-  |                   ^--^
-  |
-  = But the function expected an argument of type Value@NF { value: AppliedBuiltin(Bool, [], []), type: Type }
+Type error: Unhandled error: TypeMismatch
diff --git a/dhall/tests/type-errors/unit/MergeLhsNotRecord.txt b/dhall/tests/type-errors/unit/MergeLhsNotRecord.txt
index 785fc63..d151710 100644
--- a/dhall/tests/type-errors/unit/MergeLhsNotRecord.txt
+++ b/dhall/tests/type-errors/unit/MergeLhsNotRecord.txt
@@ -1 +1 @@
-Type error: Unhandled error: Merge1ArgMustBeRecord(Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
+Type error: Unhandled error: Merge1ArgMustBeRecord
diff --git a/dhall/tests/type-errors/unit/MergeMissingHandler1.txt b/dhall/tests/type-errors/unit/MergeMissingHandler1.txt
index d4e9024..711d77d 100644
--- a/dhall/tests/type-errors/unit/MergeMissingHandler1.txt
+++ b/dhall/tests/type-errors/unit/MergeMissingHandler1.txt
@@ -1 +1 @@
-Type error: Unhandled error: MergeVariantMissingHandler(Label("x"))
+Type error: Unhandled error: MergeVariantMissingHandler
diff --git a/dhall/tests/type-errors/unit/MergeMissingHandler2.txt b/dhall/tests/type-errors/unit/MergeMissingHandler2.txt
index d583de7..711d77d 100644
--- a/dhall/tests/type-errors/unit/MergeMissingHandler2.txt
+++ b/dhall/tests/type-errors/unit/MergeMissingHandler2.txt
@@ -1 +1 @@
-Type error: Unhandled error: MergeVariantMissingHandler(Label("y"))
+Type error: Unhandled error: MergeVariantMissingHandler
diff --git a/dhall/tests/type-errors/unit/MergeRhsNotUnion.txt b/dhall/tests/type-errors/unit/MergeRhsNotUnion.txt
index 8954538..4c72653 100644
--- a/dhall/tests/type-errors/unit/MergeRhsNotUnion.txt
+++ b/dhall/tests/type-errors/unit/MergeRhsNotUnion.txt
@@ -1 +1 @@
-Type error: Unhandled error: Merge2ArgMustBeUnionOrOptional(Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
+Type error: Unhandled error: Merge2ArgMustBeUnionOrOptional
diff --git a/dhall/tests/type-errors/unit/MergeUnusedHandler.txt b/dhall/tests/type-errors/unit/MergeUnusedHandler.txt
index b7eefdd..a429b89 100644
--- a/dhall/tests/type-errors/unit/MergeUnusedHandler.txt
+++ b/dhall/tests/type-errors/unit/MergeUnusedHandler.txt
@@ -1 +1 @@
-Type error: Unhandled error: MergeHandlerMissingVariant(Label("y"))
+Type error: Unhandled error: MergeHandlerMissingVariant
diff --git a/dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt b/dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt
index 784fd8a..9342fd8 100644
--- a/dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt
+++ b/dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt
@@ -1,13 +1 @@
- --> 1:1
-  |
-1 | Natural/subtract True True␊
-  | ^--------------^
-  |
-  = Type error: Wrong type of function argument
- --> 1:18
-  |
-1 | Natural/subtract True True␊
-  |                  ^--^
-  |
-  = This argument has type Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type }
-[unknown location] But the function expected an argument of type Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type }
+Type error: Unhandled error: TypeMismatch
diff --git a/dhall/tests/type-errors/unit/OperatorAndNotBool.txt b/dhall/tests/type-errors/unit/OperatorAndNotBool.txt
index b9314fb..9f10587 100644
--- a/dhall/tests/type-errors/unit/OperatorAndNotBool.txt
+++ b/dhall/tests/type-errors/unit/OperatorAndNotBool.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(BoolAnd, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch
diff --git a/dhall/tests/type-errors/unit/OperatorEqualNotBool.txt b/dhall/tests/type-errors/unit/OperatorEqualNotBool.txt
index 253e2f2..9f10587 100644
--- a/dhall/tests/type-errors/unit/OperatorEqualNotBool.txt
+++ b/dhall/tests/type-errors/unit/OperatorEqualNotBool.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(BoolEQ, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch
diff --git a/dhall/tests/type-errors/unit/OperatorListConcatenateLhsNotList.txt b/dhall/tests/type-errors/unit/OperatorListConcatenateLhsNotList.txt
index 735d101..9f10587 100644
--- a/dhall/tests/type-errors/unit/OperatorListConcatenateLhsNotList.txt
+++ b/dhall/tests/type-errors/unit/OperatorListConcatenateLhsNotList.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(ListAppend, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch
diff --git a/dhall/tests/type-errors/unit/OperatorListConcatenateListsNotMatch.txt b/dhall/tests/type-errors/unit/OperatorListConcatenateListsNotMatch.txt
index b931c01..9f10587 100644
--- a/dhall/tests/type-errors/unit/OperatorListConcatenateListsNotMatch.txt
+++ b/dhall/tests/type-errors/unit/OperatorListConcatenateListsNotMatch.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(ListAppend, Value@Unevaled { value: PartialExpr(NEListLit([Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } }])), type: Value@WHNF { value: AppliedBuiltin(List, [Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type }], [Value@WHNF { value: Pi(Binder(`_`), Type, Type), type: Kind }]), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch
diff --git a/dhall/tests/type-errors/unit/OperatorListConcatenateNotListsButMatch.txt b/dhall/tests/type-errors/unit/OperatorListConcatenateNotListsButMatch.txt
index 735d101..9f10587 100644
--- a/dhall/tests/type-errors/unit/OperatorListConcatenateNotListsButMatch.txt
+++ b/dhall/tests/type-errors/unit/OperatorListConcatenateNotListsButMatch.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(ListAppend, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch
diff --git a/dhall/tests/type-errors/unit/OperatorListConcatenateRhsNotList.txt b/dhall/tests/type-errors/unit/OperatorListConcatenateRhsNotList.txt
index 735d101..9f10587 100644
--- a/dhall/tests/type-errors/unit/OperatorListConcatenateRhsNotList.txt
+++ b/dhall/tests/type-errors/unit/OperatorListConcatenateRhsNotList.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(ListAppend, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch
diff --git a/dhall/tests/type-errors/unit/OperatorNotEqualNotBool.txt b/dhall/tests/type-errors/unit/OperatorNotEqualNotBool.txt
index c3c83b1..9f10587 100644
--- a/dhall/tests/type-errors/unit/OperatorNotEqualNotBool.txt
+++ b/dhall/tests/type-errors/unit/OperatorNotEqualNotBool.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(BoolNE, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch
diff --git a/dhall/tests/type-errors/unit/OperatorOrNotBool.txt b/dhall/tests/type-errors/unit/OperatorOrNotBool.txt
index 32caf35..9f10587 100644
--- a/dhall/tests/type-errors/unit/OperatorOrNotBool.txt
+++ b/dhall/tests/type-errors/unit/OperatorOrNotBool.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(BoolOr, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch
diff --git a/dhall/tests/type-errors/unit/OperatorPlusNotNatural.txt b/dhall/tests/type-errors/unit/OperatorPlusNotNatural.txt
index 4e578c4..9f10587 100644
--- a/dhall/tests/type-errors/unit/OperatorPlusNotNatural.txt
+++ b/dhall/tests/type-errors/unit/OperatorPlusNotNatural.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(NaturalPlus, Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch
diff --git a/dhall/tests/type-errors/unit/OperatorTextConcatenateLhsNotText.txt b/dhall/tests/type-errors/unit/OperatorTextConcatenateLhsNotText.txt
index 58d4b23..9f10587 100644
--- a/dhall/tests/type-errors/unit/OperatorTextConcatenateLhsNotText.txt
+++ b/dhall/tests/type-errors/unit/OperatorTextConcatenateLhsNotText.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(TextAppend, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch
diff --git a/dhall/tests/type-errors/unit/OperatorTextConcatenateRhsNotText.txt b/dhall/tests/type-errors/unit/OperatorTextConcatenateRhsNotText.txt
index 58d4b23..9f10587 100644
--- a/dhall/tests/type-errors/unit/OperatorTextConcatenateRhsNotText.txt
+++ b/dhall/tests/type-errors/unit/OperatorTextConcatenateRhsNotText.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(TextAppend, Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch
diff --git a/dhall/tests/type-errors/unit/OperatorTimesNotNatural.txt b/dhall/tests/type-errors/unit/OperatorTimesNotNatural.txt
index 8caf338..9f10587 100644
--- a/dhall/tests/type-errors/unit/OperatorTimesNotNatural.txt
+++ b/dhall/tests/type-errors/unit/OperatorTimesNotNatural.txt
@@ -1 +1 @@
-Type error: Unhandled error: BinOpTypeMismatch(NaturalTimes, Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
+Type error: Unhandled error: BinOpTypeMismatch
diff --git a/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxAbsent.txt b/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxAbsent.txt
index e524a07..3937453 100644
--- a/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxAbsent.txt
+++ b/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxAbsent.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidListType(Value@WHNF { value: AppliedBuiltin(Optional, [Value@Unevaled { value: AppliedBuiltin(Bool, [], []), type: Type }], [Value@WHNF { value: Pi(Binder(`_`), Type, Type), type: Kind }]), type: Type })
+Type error: Unhandled error: InvalidListType
diff --git a/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxPresent.txt b/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxPresent.txt
index 5ff6a69..045eb98 100644
--- a/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxPresent.txt
+++ b/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxPresent.txt
@@ -1 +1 @@
-Type error: Unhandled error: AnnotMismatch(Value@Unevaled { value: PartialExpr(NEListLit([Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@Unevaled { value: AppliedBuiltin(Natural, [], []), type: Type } }])), type: Value@WHNF { value: AppliedBuiltin(List, [Value@Unevaled { value: AppliedBuiltin(Natural, [], []), type: Type }], [Value@WHNF { value: Pi(Binder(`_`), Type, Type), type: Kind }]), type: Type } }, Value@WHNF { value: AppliedBuiltin(Optional, [Value@Unevaled { value: AppliedBuiltin(Natural, [], []), type: Type }], [Value@WHNF { value: Pi(Binder(`_`), Type, Type), type: Kind }]), type: Type })
+Type error: Unhandled error: AnnotMismatch
diff --git a/dhall/tests/type-errors/unit/RecordSelectionEmpty.txt b/dhall/tests/type-errors/unit/RecordSelectionEmpty.txt
index 1770faa..ea48374 100644
--- a/dhall/tests/type-errors/unit/RecordSelectionEmpty.txt
+++ b/dhall/tests/type-errors/unit/RecordSelectionEmpty.txt
@@ -1 +1 @@
-Type error: Unhandled error: MissingRecordField(Label("x"), Value@Unevaled { value: PartialExpr(RecordLit(DupTreeMap { map: {}, size: 0 })), type: Value@WHNF { value: RecordType({}), type: Type } })
+Type error: Unhandled error: MissingRecordField
diff --git a/dhall/tests/type-errors/unit/RecordSelectionNotPresent.txt b/dhall/tests/type-errors/unit/RecordSelectionNotPresent.txt
index 9211e05..ea48374 100644
--- a/dhall/tests/type-errors/unit/RecordSelectionNotPresent.txt
+++ b/dhall/tests/type-errors/unit/RecordSelectionNotPresent.txt
@@ -1 +1 @@
-Type error: Unhandled error: MissingRecordField(Label("x"), Value@Unevaled { value: PartialExpr(RecordLit(DupTreeMap { map: {Label("y"): [Value@Unevaled { value: PartialExpr(RecordLit(DupTreeMap { map: {}, size: 0 })), type: Value@Unevaled { value: RecordType({}), type: Type } }]}, size: 1 })), type: Value@WHNF { value: RecordType({Label("y"): Value@Unevaled { value: RecordType({}), type: Type }}), type: Type } })
+Type error: Unhandled error: MissingRecordField
diff --git a/dhall/tests/type-errors/unit/RecordSelectionNotRecord.txt b/dhall/tests/type-errors/unit/RecordSelectionNotRecord.txt
index 292ab0e..35d604f 100644
--- a/dhall/tests/type-errors/unit/RecordSelectionNotRecord.txt
+++ b/dhall/tests/type-errors/unit/RecordSelectionNotRecord.txt
@@ -1 +1 @@
-Type error: Unhandled error: NotARecord(Label("x"), Value@WHNF { value: BoolLit(true), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
+Type error: Unhandled error: NotARecord
diff --git a/dhall/tests/type-errors/unit/RecordSelectionTypeNotUnionType.txt b/dhall/tests/type-errors/unit/RecordSelectionTypeNotUnionType.txt
index dff292e..35d604f 100644
--- a/dhall/tests/type-errors/unit/RecordSelectionTypeNotUnionType.txt
+++ b/dhall/tests/type-errors/unit/RecordSelectionTypeNotUnionType.txt
@@ -1 +1 @@
-Type error: Unhandled error: NotARecord(Label("x"), Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type })
+Type error: Unhandled error: NotARecord
diff --git a/dhall/tests/type-errors/unit/RecursiveRecordMergeLhsNotRecord.txt b/dhall/tests/type-errors/unit/RecursiveRecordMergeLhsNotRecord.txt
index 27ed928..7fd03d3 100644
--- a/dhall/tests/type-errors/unit/RecursiveRecordMergeLhsNotRecord.txt
+++ b/dhall/tests/type-errors/unit/RecursiveRecordMergeLhsNotRecord.txt
@@ -1 +1 @@
-Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type })
+Type error: Unhandled error: RecordTypeMergeRequiresRecordType
diff --git a/dhall/tests/type-errors/unit/RecursiveRecordMergeOverlapping.txt b/dhall/tests/type-errors/unit/RecursiveRecordMergeOverlapping.txt
index 27ed928..7fd03d3 100644
--- a/dhall/tests/type-errors/unit/RecursiveRecordMergeOverlapping.txt
+++ b/dhall/tests/type-errors/unit/RecursiveRecordMergeOverlapping.txt
@@ -1 +1 @@
-Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type })
+Type error: Unhandled error: RecordTypeMergeRequiresRecordType
diff --git a/dhall/tests/type-errors/unit/RecursiveRecordMergeRhsNotRecord.txt b/dhall/tests/type-errors/unit/RecursiveRecordMergeRhsNotRecord.txt
index 27ed928..7fd03d3 100644
--- a/dhall/tests/type-errors/unit/RecursiveRecordMergeRhsNotRecord.txt
+++ b/dhall/tests/type-errors/unit/RecursiveRecordMergeRhsNotRecord.txt
@@ -1 +1 @@
-Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type })
+Type error: Unhandled error: RecordTypeMergeRequiresRecordType
diff --git a/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeLhsNotRecordType.txt b/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeLhsNotRecordType.txt
index 27ed928..7fd03d3 100644
--- a/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeLhsNotRecordType.txt
+++ b/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeLhsNotRecordType.txt
@@ -1 +1 @@
-Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type })
+Type error: Unhandled error: RecordTypeMergeRequiresRecordType
diff --git a/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeOverlapping.txt b/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeOverlapping.txt
index 27ed928..7fd03d3 100644
--- a/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeOverlapping.txt
+++ b/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeOverlapping.txt
@@ -1 +1 @@
-Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type })
+Type error: Unhandled error: RecordTypeMergeRequiresRecordType
diff --git a/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeRhsNotRecordType.txt b/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeRhsNotRecordType.txt
index 27ed928..7fd03d3 100644
--- a/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeRhsNotRecordType.txt
+++ b/dhall/tests/type-errors/unit/RecursiveRecordTypeMergeRhsNotRecordType.txt
@@ -1 +1 @@
-Type error: Unhandled error: RecordTypeMergeRequiresRecordType(Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type })
+Type error: Unhandled error: RecordTypeMergeRequiresRecordType
diff --git a/dhall/tests/type-errors/unit/RightBiasedRecordMergeLhsNotRecord.txt b/dhall/tests/type-errors/unit/RightBiasedRecordMergeLhsNotRecord.txt
index fbb410f..42600a4 100644
--- a/dhall/tests/type-errors/unit/RightBiasedRecordMergeLhsNotRecord.txt
+++ b/dhall/tests/type-errors/unit/RightBiasedRecordMergeLhsNotRecord.txt
@@ -1 +1 @@
-Type error: Unhandled error: MustCombineRecord(Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
+Type error: Unhandled error: MustCombineRecord
diff --git a/dhall/tests/type-errors/unit/RightBiasedRecordMergeRhsNotRecord.txt b/dhall/tests/type-errors/unit/RightBiasedRecordMergeRhsNotRecord.txt
index fbb410f..42600a4 100644
--- a/dhall/tests/type-errors/unit/RightBiasedRecordMergeRhsNotRecord.txt
+++ b/dhall/tests/type-errors/unit/RightBiasedRecordMergeRhsNotRecord.txt
@@ -1 +1 @@
-Type error: Unhandled error: MustCombineRecord(Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
+Type error: Unhandled error: MustCombineRecord
diff --git a/dhall/tests/type-errors/unit/SomeNotType.txt b/dhall/tests/type-errors/unit/SomeNotType.txt
index 43581a0..63fec72 100644
--- a/dhall/tests/type-errors/unit/SomeNotType.txt
+++ b/dhall/tests/type-errors/unit/SomeNotType.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidOptionalType(Type)
+Type error: Unhandled error: InvalidOptionalType
diff --git a/dhall/tests/type-errors/unit/TextLiteralInterpolateNotText.txt b/dhall/tests/type-errors/unit/TextLiteralInterpolateNotText.txt
index feb6b2e..f1a77d9 100644
--- a/dhall/tests/type-errors/unit/TextLiteralInterpolateNotText.txt
+++ b/dhall/tests/type-errors/unit/TextLiteralInterpolateNotText.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidTextInterpolation(Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } })
+Type error: Unhandled error: InvalidTextInterpolation
diff --git a/dhall/tests/type-errors/unit/TypeAnnotationWrong.txt b/dhall/tests/type-errors/unit/TypeAnnotationWrong.txt
index 869e9c3..045eb98 100644
--- a/dhall/tests/type-errors/unit/TypeAnnotationWrong.txt
+++ b/dhall/tests/type-errors/unit/TypeAnnotationWrong.txt
@@ -1 +1 @@
-Type error: Unhandled error: AnnotMismatch(Value@Unevaled { value: PartialExpr(NaturalLit(1)), type: Value@WHNF { value: AppliedBuiltin(Natural, [], []), type: Type } }, Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type })
+Type error: Unhandled error: AnnotMismatch
diff --git a/dhall/tests/type-errors/unit/UnionConstructorFieldNotPresent.txt b/dhall/tests/type-errors/unit/UnionConstructorFieldNotPresent.txt
index eb3e09a..f88cb57 100644
--- a/dhall/tests/type-errors/unit/UnionConstructorFieldNotPresent.txt
+++ b/dhall/tests/type-errors/unit/UnionConstructorFieldNotPresent.txt
@@ -1 +1 @@
-Type error: Unhandled error: MissingUnionField(Label("y"), Value@WHNF { value: UnionType({Label("x"): Some(Value@Unevaled { value: AppliedBuiltin(Bool, [], []), type: Type })}), type: Type })
+Type error: Unhandled error: MissingUnionField
-- 
cgit v1.2.3


From 574fb56e87c1a71dc8d7efbff2789d3cfabdc529 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 25 Jan 2020 13:51:24 +0000
Subject: More typecheck

---
 dhall/src/semantics/phase/normalize.rs |  19 ++-
 dhall/src/semantics/phase/typecheck.rs | 101 +++++++-------
 dhall/src/semantics/tck/typecheck.rs   | 239 +++++++++++++++++++++++++++++++--
 3 files changed, 301 insertions(+), 58 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index 7f547d7..33e1f2b 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -595,8 +595,23 @@ fn apply_binop<'a>(
             Ret::ValueKind(RecordLit(kvs))
         }
 
-        (RecursiveRecordTypeMerge, _, _) => {
-            unreachable!("This case should have been handled in typecheck")
+        (RecursiveRecordTypeMerge, RecordType(kts_x), RecordType(kts_y)) => {
+            let kts = merge_maps::<_, _, _, !>(
+                kts_x,
+                kts_y,
+                // If the Label exists for both records, then we hit the recursive case.
+                |_, l: &Value, r: &Value| {
+                    Ok(Value::from_kind_and_type(
+                        ValueKind::PartialExpr(ExprKind::BinOp(
+                            RecursiveRecordTypeMerge,
+                            l.clone(),
+                            r.clone(),
+                        )),
+                        ty.clone(),
+                    ))
+                },
+            )?;
+            Ret::ValueKind(RecordType(kts))
         }
 
         (Equivalence, _, _) => {
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index 44678cd..1aab736 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -356,7 +356,6 @@ fn type_last_layer(
     use syntax::BinOp::*;
     use syntax::Builtin::*;
     use syntax::Const::Type;
-    use syntax::ExprKind::*;
     let mkerr =
         |msg: &str| Err(TypeError::new(TypeMessage::Custom(msg.to_string())));
 
@@ -370,13 +369,15 @@ fn type_last_layer(
     use Ret::*;
 
     let ret = match &e {
-        Import(_) => unreachable!(
+        ExprKind::Import(_) => unreachable!(
             "There should remain no imports in a resolved expression"
         ),
-        Lam(_, _, _) | Pi(_, _, _) | Let(_, _, _, _) | Embed(_) | Var(_) => {
-            unreachable!()
-        }
-        App(f, a) => {
+        ExprKind::Lam(_, _, _)
+        | ExprKind::Pi(_, _, _)
+        | ExprKind::Let(_, _, _, _)
+        | ExprKind::Embed(_)
+        | ExprKind::Var(_) => unreachable!(),
+        ExprKind::App(f, a) => {
             let tf = f.get_type()?;
             let tf_borrow = tf.as_whnf();
             let (tx, tb) = match &*tf_borrow {
@@ -391,13 +392,13 @@ fn type_last_layer(
             ret.normalize_nf();
             RetTypeOnly(ret)
         }
-        Annot(x, t) => {
+        ExprKind::Annot(x, t) => {
             if &x.get_type()? != t {
                 return mkerr("AnnotMismatch");
             }
             RetWhole(x.clone())
         }
-        Assert(t) => {
+        ExprKind::Assert(t) => {
             match &*t.as_whnf() {
                 ValueKind::Equivalence(x, y) if x == y => {}
                 ValueKind::Equivalence(..) => return mkerr("AssertMismatch"),
@@ -405,16 +406,16 @@ fn type_last_layer(
             }
             RetTypeOnly(t.clone())
         }
-        BoolIf(x, y, z) => {
+        ExprKind::BoolIf(x, y, z) => {
             if *x.get_type()?.as_whnf() != ValueKind::from_builtin(Bool) {
                 return mkerr("InvalidPredicate");
             }
 
-            if y.get_type()?.get_type()?.as_const() != Some(Type) {
+            if y.get_type()?.get_type()?.as_const() != Some(Const::Type) {
                 return mkerr("IfBranchMustBeTerm");
             }
 
-            if z.get_type()?.get_type()?.as_const() != Some(Type) {
+            if z.get_type()?.get_type()?.as_const() != Some(Const::Type) {
                 return mkerr("IfBranchMustBeTerm");
             }
 
@@ -424,7 +425,7 @@ fn type_last_layer(
 
             RetTypeOnly(y.get_type()?)
         }
-        EmptyListLit(t) => {
+        ExprKind::EmptyListLit(t) => {
             let arg = match &*t.as_whnf() {
                 ValueKind::AppliedBuiltin(syntax::Builtin::List, args, _)
                     if args.len() == 1 =>
@@ -438,7 +439,7 @@ fn type_last_layer(
                 t.clone(),
             ))
         }
-        NEListLit(xs) => {
+        ExprKind::NEListLit(xs) => {
             let mut iter = xs.iter().enumerate();
             let (_, x) = iter.next().unwrap();
             for (_, y) in iter {
@@ -447,30 +448,30 @@ fn type_last_layer(
                 }
             }
             let t = x.get_type()?;
-            if t.get_type()?.as_const() != Some(Type) {
+            if t.get_type()?.as_const() != Some(Const::Type) {
                 return mkerr("InvalidListType");
             }
 
             RetTypeOnly(Value::from_builtin(syntax::Builtin::List).app(t))
         }
-        SomeLit(x) => {
+        ExprKind::SomeLit(x) => {
             let t = x.get_type()?;
-            if t.get_type()?.as_const() != Some(Type) {
+            if t.get_type()?.as_const() != Some(Const::Type) {
                 return mkerr("InvalidOptionalType");
             }
 
             RetTypeOnly(Value::from_builtin(syntax::Builtin::Optional).app(t))
         }
-        RecordType(kts) => RetWhole(tck_record_type(
+        ExprKind::RecordType(kts) => RetWhole(tck_record_type(
             kts.iter().map(|(x, t)| Ok((x.clone(), t.clone()))),
         )?),
-        UnionType(kts) => RetWhole(tck_union_type(
+        ExprKind::UnionType(kts) => RetWhole(tck_union_type(
             kts.iter().map(|(x, t)| Ok((x.clone(), t.clone()))),
         )?),
-        RecordLit(kvs) => RetTypeOnly(tck_record_type(
+        ExprKind::RecordLit(kvs) => RetTypeOnly(tck_record_type(
             kvs.iter().map(|(x, v)| Ok((x.clone(), v.get_type()?))),
         )?),
-        Field(r, x) => {
+        ExprKind::Field(r, x) => {
             match &*r.get_type()?.as_whnf() {
                 ValueKind::RecordType(kts) => match kts.get(&x) {
                     Some(tth) => RetTypeOnly(tth.clone()),
@@ -494,13 +495,13 @@ fn type_last_layer(
                 } // _ => mkerr("NotARecord"),
             }
         }
-        Const(c) => RetWhole(const_to_value(*c)),
-        Builtin(b) => RetWhole(builtin_to_value(*b)),
-        BoolLit(_) => RetTypeOnly(builtin_to_value(Bool)),
-        NaturalLit(_) => RetTypeOnly(builtin_to_value(Natural)),
-        IntegerLit(_) => RetTypeOnly(builtin_to_value(Integer)),
-        DoubleLit(_) => RetTypeOnly(builtin_to_value(Double)),
-        TextLit(interpolated) => {
+        ExprKind::Const(c) => RetWhole(const_to_value(*c)),
+        ExprKind::Builtin(b) => RetWhole(builtin_to_value(*b)),
+        ExprKind::BoolLit(_) => RetTypeOnly(builtin_to_value(Bool)),
+        ExprKind::NaturalLit(_) => RetTypeOnly(builtin_to_value(Natural)),
+        ExprKind::IntegerLit(_) => RetTypeOnly(builtin_to_value(Integer)),
+        ExprKind::DoubleLit(_) => RetTypeOnly(builtin_to_value(Double)),
+        ExprKind::TextLit(interpolated) => {
             let text_type = builtin_to_value(Text);
             for contents in interpolated.iter() {
                 use InterpolatedTextContents::Expr;
@@ -512,7 +513,7 @@ fn type_last_layer(
             }
             RetTypeOnly(text_type)
         }
-        BinOp(RightBiasedRecordMerge, l, r) => {
+        ExprKind::BinOp(RightBiasedRecordMerge, l, r) => {
             let l_type = l.get_type()?;
             let r_type = r.get_type()?;
 
@@ -541,16 +542,18 @@ fn type_last_layer(
                 kts.into_iter().map(|(x, v)| Ok((x.clone(), v))),
             )?)
         }
-        BinOp(RecursiveRecordMerge, l, r) => RetTypeOnly(type_last_layer(
-            ctx,
-            ExprKind::BinOp(
-                RecursiveRecordTypeMerge,
-                l.get_type()?,
-                r.get_type()?,
-            ),
-            Span::Artificial,
-        )?),
-        BinOp(RecursiveRecordTypeMerge, l, r) => {
+        ExprKind::BinOp(RecursiveRecordMerge, l, r) => {
+            RetTypeOnly(type_last_layer(
+                ctx,
+                ExprKind::BinOp(
+                    RecursiveRecordTypeMerge,
+                    l.get_type()?,
+                    r.get_type()?,
+                ),
+                Span::Artificial,
+            )?)
+        }
+        ExprKind::BinOp(RecursiveRecordTypeMerge, l, r) => {
             // Extract the LHS record type
             let borrow_l = l.as_whnf();
             let kts_x = match &*borrow_l {
@@ -585,7 +588,7 @@ fn type_last_layer(
 
             RetWhole(tck_record_type(kts.into_iter().map(Ok))?)
         }
-        BinOp(ListAppend, l, r) => {
+        ExprKind::BinOp(ListAppend, l, r) => {
             match &*l.get_type()?.as_whnf() {
                 ValueKind::AppliedBuiltin(List, _, _) => {}
                 _ => return mkerr("BinOpTypeMismatch"),
@@ -597,11 +600,11 @@ fn type_last_layer(
 
             RetTypeOnly(l.get_type()?)
         }
-        BinOp(Equivalence, l, r) => {
-            if l.get_type()?.get_type()?.as_const() != Some(Type) {
+        ExprKind::BinOp(Equivalence, l, r) => {
+            if l.get_type()?.get_type()?.as_const() != Some(Const::Type) {
                 return mkerr("EquivalenceArgumentMustBeTerm");
             }
-            if r.get_type()?.get_type()?.as_const() != Some(Type) {
+            if r.get_type()?.get_type()?.as_const() != Some(Const::Type) {
                 return mkerr("EquivalenceArgumentMustBeTerm");
             }
 
@@ -614,7 +617,7 @@ fn type_last_layer(
                 Value::from_const(Type),
             ))
         }
-        BinOp(o, l, r) => {
+        ExprKind::BinOp(o, l, r) => {
             let t = builtin_to_value(match o {
                 BoolAnd => Bool,
                 BoolOr => Bool,
@@ -641,7 +644,7 @@ fn type_last_layer(
 
             RetTypeOnly(t)
         }
-        Merge(record, union, type_annot) => {
+        ExprKind::Merge(record, union, type_annot) => {
             let record_type = record.get_type()?;
             let record_borrow = record_type.as_whnf();
             let handlers = match &*record_borrow {
@@ -723,8 +726,8 @@ fn type_last_layer(
                 (None, None) => return mkerr("MergeEmptyNeedsAnnotation"),
             }
         }
-        ToMap(_, _) => unimplemented!("toMap"),
-        Projection(record, labels) => {
+        ExprKind::ToMap(_, _) => unimplemented!("toMap"),
+        ExprKind::Projection(record, labels) => {
             let record_type = record.get_type()?;
             let record_type_borrow = record_type.as_whnf();
             let kts = match &*record_type_borrow {
@@ -753,8 +756,10 @@ fn type_last_layer(
                 record_type.get_type()?,
             ))
         }
-        ProjectionByExpr(_, _) => unimplemented!("selection by expression"),
-        Completion(_, _) => unimplemented!("record completion"),
+        ExprKind::ProjectionByExpr(_, _) => {
+            unimplemented!("selection by expression")
+        }
+        ExprKind::Completion(_, _) => unimplemented!("record completion"),
     };
 
     Ok(match ret {
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index 52c7ac7..1687185 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -19,8 +19,8 @@ use crate::semantics::{
 };
 use crate::syntax;
 use crate::syntax::{
-    Builtin, Const, Expr, ExprKind, InterpolatedTextContents, Label, Span,
-    UnspannedExpr, V,
+    BinOp, Builtin, Const, Expr, ExprKind, InterpolatedTextContents, Label,
+    Span, UnspannedExpr, V,
 };
 
 #[derive(Debug, Clone)]
@@ -46,7 +46,7 @@ impl TyEnv {
         &self.names
     }
 
-    pub fn insert_type(&self, x: &Label, t: Value) -> Self {
+    pub fn insert_type(&self, x: &Label, t: Type) -> Self {
         TyEnv {
             names: self.names.insert(x),
             items: self.items.insert_type(t),
@@ -58,7 +58,7 @@ impl TyEnv {
             items: self.items.insert_value(e),
         }
     }
-    pub fn lookup(&self, var: &V<Label>) -> Option<(TyExprKind, Value)> {
+    pub fn lookup(&self, var: &V<Label>) -> Option<(TyExprKind, Type)> {
         let var = self.names.unlabel_var(var)?;
         let ty = self.items.lookup_val(&var).get_type().unwrap();
         Some((TyExprKind::Var(var), ty))
@@ -72,10 +72,10 @@ fn mkerr<T>(x: impl ToString) -> Result<T, TypeError> {
     Err(TypeError::new(TypeMessage::Custom(x.to_string())))
 }
 
-fn type_last_layer(
+fn type_one_layer(
     env: &TyEnv,
     kind: &ExprKind<TyExpr, Normalized>,
-) -> Result<Value, TypeError> {
+) -> Result<Type, TypeError> {
     Ok(match &kind {
         ExprKind::Import(..) => unreachable!(
             "There should remain no imports in a resolved expression"
@@ -85,7 +85,7 @@ fn type_last_layer(
         | ExprKind::Pi(..)
         | ExprKind::Let(..)
         | ExprKind::Const(Const::Sort)
-        | ExprKind::Embed(..) => unreachable!(),
+        | ExprKind::Embed(..) => unreachable!(), // Handled in type_with
 
         ExprKind::Const(Const::Type) => const_to_value(Const::Kind),
         ExprKind::Const(Const::Kind) => const_to_value(Const::Sort),
@@ -96,7 +96,99 @@ fn type_last_layer(
         ExprKind::NaturalLit(_) => builtin_to_value(Builtin::Natural),
         ExprKind::IntegerLit(_) => builtin_to_value(Builtin::Integer),
         ExprKind::DoubleLit(_) => builtin_to_value(Builtin::Double),
+        ExprKind::TextLit(interpolated) => {
+            let text_type = builtin_to_value(Builtin::Text);
+            for contents in interpolated.iter() {
+                use InterpolatedTextContents::Expr;
+                if let Expr(x) = contents {
+                    if x.get_type()? != text_type {
+                        return mkerr("InvalidTextInterpolation");
+                    }
+                }
+            }
+            text_type
+        }
+
+        // ExprKind::EmptyListLit(t) => {
+        //     let arg = match &*t.as_whnf() {
+        //         ValueKind::AppliedBuiltin(Builtin::List, args, _)
+        //             if args.len() == 1 =>
+        //         {
+        //             args[0].clone()
+        //         }
+        //         _ => return mkerr("InvalidListType"),
+        //     };
+        //     RetWhole(Value::from_kind_and_type(
+        //         ValueKind::EmptyListLit(arg),
+        //         t.clone(),
+        //     ))
+        // }
+        ExprKind::NEListLit(xs) => {
+            let mut iter = xs.iter().enumerate();
+            let (_, x) = iter.next().unwrap();
+            for (i, y) in iter {
+                if x.get_type()? != y.get_type()? {
+                    return mkerr("InvalidListElement");
+                }
+            }
+            let t = x.get_type()?;
+            if t.get_type()?.as_const() != Some(Const::Type) {
+                return mkerr("InvalidListType");
+            }
+
+            Value::from_builtin(Builtin::List).app(t)
+        }
+        ExprKind::SomeLit(x) => {
+            let t = x.get_type()?;
+            if t.get_type()?.as_const() != Some(Const::Type) {
+                return mkerr("InvalidOptionalType");
+            }
 
+            Value::from_builtin(Builtin::Optional).app(t)
+        }
+        // ExprKind::RecordType(kts) => RetWhole(tck_record_type(
+        //     kts.iter().map(|(x, t)| Ok((x.clone(), t.clone()))),
+        // )?),
+        // ExprKind::UnionType(kts) => RetWhole(tck_union_type(
+        //     kts.iter().map(|(x, t)| Ok((x.clone(), t.clone()))),
+        // )?),
+        // ExprKind::RecordLit(kvs) => RetTypeOnly(tck_record_type(
+        //     kvs.iter().map(|(x, v)| Ok((x.clone(), v.get_type()?))),
+        // )?),
+        ExprKind::Field(r, x) => {
+            match &*r.get_type()?.as_whnf() {
+                ValueKind::RecordType(kts) => match kts.get(&x) {
+                    Some(tth) => tth.clone(),
+                    None => return mkerr("MissingRecordField"),
+                },
+                // TODO: branch here only when r.get_type() is a Const
+                _ => {
+                    let r_nf = r.normalize_whnf(env.as_nzenv());
+                    let r_nf_borrow = r_nf.as_whnf();
+                    match &*r_nf_borrow {
+                        ValueKind::UnionType(kts) => match kts.get(x) {
+                            // Constructor has type T -> < x: T, ... >
+                            // TODO: check pi type properly
+                            Some(Some(t)) => Value::from_kind_and_type(
+                                ValueKind::PiClosure {
+                                    binder: Binder::new(x.clone()),
+                                    annot: t.clone(),
+                                    closure: Closure::new(
+                                        t.clone(),
+                                        env.as_nzenv(),
+                                        r.clone(),
+                                    ),
+                                },
+                                Value::from_const(Const::Type),
+                            ),
+                            Some(None) => r_nf.clone(),
+                            None => return mkerr("MissingUnionField"),
+                        },
+                        _ => return mkerr("NotARecord"),
+                    }
+                } // _ => mkerr("NotARecord"),
+            }
+        }
         ExprKind::Annot(x, t) => {
             if x.get_type()? != t.normalize_whnf(env.as_nzenv()) {
                 return mkerr("annot mismatch");
@@ -139,7 +231,138 @@ fn type_last_layer(
 
             y.get_type()?
         }
+        // ExprKind::BinOp(BinOp::RightBiasedRecordMerge, l, r) => {
+        //     let l_type = l.get_type()?;
+        //     let r_type = r.get_type()?;
+
+        //     // Extract the LHS record type
+        //     let l_type_borrow = l_type.as_whnf();
+        //     let kts_x = match &*l_type_borrow {
+        //         ValueKind::RecordType(kts) => kts,
+        //         _ => return mkerr("MustCombineRecord"),
+        //     };
+
+        //     // Extract the RHS record type
+        //     let r_type_borrow = r_type.as_whnf();
+        //     let kts_y = match &*r_type_borrow {
+        //         ValueKind::RecordType(kts) => kts,
+        //         _ => return mkerr("MustCombineRecord"),
+        //     };
 
+        //     // Union the two records, prefering
+        //     // the values found in the RHS.
+        //     let kts = merge_maps::<_, _, _, !>(kts_x, kts_y, |_, _, r_t| {
+        //         Ok(r_t.clone())
+        //     })?;
+
+        //     // Construct the final record type from the union
+        //     RetTypeOnly(tck_record_type(
+        //         kts.into_iter().map(|(x, v)| Ok((x.clone(), v))),
+        //     )?)
+        // }
+        // ExprKind::BinOp(BinOp::RecursiveRecordMerge, l, r) => RetTypeOnly(type_last_layer(
+        //     ctx,
+        //     ExprKind::BinOp(
+        //         RecursiveRecordTypeMerge,
+        //         l.get_type()?,
+        //         r.get_type()?,
+        //     ),
+        //     Span::Artificial,
+        // )?),
+        // ExprKind::BinOp(BinOp::RecursiveRecordTypeMerge, l, r) => {
+        //     // Extract the LHS record type
+        //     let borrow_l = l.as_whnf();
+        //     let kts_x = match &*borrow_l {
+        //         ValueKind::RecordType(kts) => kts,
+        //         _ => {
+        //             return mkerr("RecordTypeMergeRequiresRecordType")
+        //         }
+        //     };
+
+        //     // Extract the RHS record type
+        //     let borrow_r = r.as_whnf();
+        //     let kts_y = match &*borrow_r {
+        //         ValueKind::RecordType(kts) => kts,
+        //         _ => {
+        //             return mkerr("RecordTypeMergeRequiresRecordType")
+        //         }
+        //     };
+
+        //     // Ensure that the records combine without a type error
+        //     let kts = merge_maps(
+        //         kts_x,
+        //         kts_y,
+        //         // If the Label exists for both records, then we hit the recursive case.
+        //         |_, l: &Value, r: &Value| {
+        //             type_last_layer(
+        //                 ctx,
+        //                 ExprKind::BinOp(
+        //                     RecursiveRecordTypeMerge,
+        //                     l.clone(),
+        //                     r.clone(),
+        //                 ),
+        //                 Span::Artificial,
+        //             )
+        //         },
+        //     )?;
+
+        //     RetWhole(tck_record_type(kts.into_iter().map(Ok))?)
+        // }
+        // ExprKind::BinOp(o @ BinOp::ListAppend, l, r) => {
+        //     match &*l.get_type()?.as_whnf() {
+        //         ValueKind::AppliedBuiltin(List, _, _) => {}
+        //         _ => return mkerr("BinOpTypeMismatch"),
+        //     }
+
+        //     if l.get_type()? != r.get_type()? {
+        //         return mkerr("BinOpTypeMismatch");
+        //     }
+
+        //     l.get_type()?
+        // }
+        // ExprKind::BinOp(BinOp::Equivalence, l, r) => {
+        //     if l.get_type()?.get_type()?.as_const() != Some(Const::Type) {
+        //         return mkerr("EquivalenceArgumentMustBeTerm");
+        //     }
+        //     if r.get_type()?.get_type()?.as_const() != Some(Const::Type) {
+        //         return mkerr("EquivalenceArgumentMustBeTerm");
+        //     }
+
+        //     if l.get_type()? != r.get_type()? {
+        //         return mkerr("EquivalenceTypeMismatch");
+        //     }
+
+        //     RetWhole(Value::from_kind_and_type(
+        //         ValueKind::Equivalence(l.clone(), r.clone()),
+        //         Value::from_const(Type),
+        //     ))
+        // }
+        ExprKind::BinOp(o, l, r) => {
+            let t = builtin_to_value(match o {
+                BinOp::BoolAnd
+                | BinOp::BoolOr
+                | BinOp::BoolEQ
+                | BinOp::BoolNE => Builtin::Bool,
+                BinOp::NaturalPlus | BinOp::NaturalTimes => Builtin::Natural,
+                BinOp::TextAppend => Builtin::Text,
+                BinOp::ListAppend
+                | BinOp::RightBiasedRecordMerge
+                | BinOp::RecursiveRecordMerge
+                | BinOp::RecursiveRecordTypeMerge
+                | BinOp::Equivalence => unreachable!(),
+                BinOp::ImportAlt => unreachable!("ImportAlt leftover in tck"),
+            });
+
+            if l.get_type()? != t {
+                return mkerr("BinOpTypeMismatch");
+            }
+
+            if r.get_type()? != t {
+                return mkerr("BinOpTypeMismatch");
+            }
+
+            t
+        }
         _ => Value::from_const(Const::Type), // TODO
     })
 }
@@ -216,7 +439,7 @@ fn type_with(
         }
         ekind => {
             let ekind = ekind.traverse_ref(|e| type_with(env, e))?;
-            let ty = type_last_layer(env, &ekind)?;
+            let ty = type_one_layer(env, &ekind)?;
             (TyExprKind::Expr(ekind), Some(ty))
         }
     };
-- 
cgit v1.2.3


From 6c51ad1da8dc4df54618af80b445bf49f771ec43 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 25 Jan 2020 15:49:16 +0000
Subject: Moar typecheck

---
 dhall/src/semantics/tck/typecheck.rs | 487 ++++++++++++++++++++++++-----------
 1 file changed, 342 insertions(+), 145 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index 1687185..1b64d28 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -1,5 +1,4 @@
 #![allow(dead_code)]
-#![allow(unused_variables)]
 #![allow(unreachable_code)]
 #![allow(unused_imports)]
 use std::borrow::Cow;
@@ -68,6 +67,41 @@ impl TyEnv {
     }
 }
 
+fn type_of_recordtype<'a>(
+    tys: impl Iterator<Item = Cow<'a, TyExpr>>,
+) -> Result<Type, TypeError> {
+    // An empty record type has type Type
+    let mut k = Const::Type;
+    for t in tys {
+        match t.get_type()?.as_const() {
+            Some(c) => k = max(k, c),
+            None => return mkerr("InvalidFieldType"),
+        }
+    }
+    Ok(Value::from_const(k))
+}
+
+fn function_check(a: Const, b: Const) -> Const {
+    if b == Const::Type {
+        Const::Type
+    } else {
+        max(a, b)
+    }
+}
+
+fn type_of_function(src: Type, tgt: Type) -> Result<Type, TypeError> {
+    let ks = match src.as_const() {
+        Some(k) => k,
+        _ => return Err(TypeError::new(TypeMessage::InvalidInputType(src))),
+    };
+    let kt = match tgt.as_const() {
+        Some(k) => k,
+        _ => return Err(TypeError::new(TypeMessage::InvalidOutputType(tgt))),
+    };
+
+    Ok(Value::from_const(function_check(ks, kt)))
+}
+
 fn mkerr<T>(x: impl ToString) -> Result<T, TypeError> {
     Err(TypeError::new(TypeMessage::Custom(x.to_string())))
 }
@@ -76,7 +110,7 @@ fn type_one_layer(
     env: &TyEnv,
     kind: &ExprKind<TyExpr, Normalized>,
 ) -> Result<Type, TypeError> {
-    Ok(match &kind {
+    Ok(match kind {
         ExprKind::Import(..) => unreachable!(
             "There should remain no imports in a resolved expression"
         ),
@@ -90,7 +124,9 @@ fn type_one_layer(
         ExprKind::Const(Const::Type) => const_to_value(Const::Kind),
         ExprKind::Const(Const::Kind) => const_to_value(Const::Sort),
         ExprKind::Builtin(b) => {
-            type_with(env, &type_of_builtin(*b))?.normalize_whnf(env.as_nzenv())
+            let t_expr = type_of_builtin(*b);
+            let t_tyexpr = type_with(env, &t_expr)?;
+            t_tyexpr.normalize_whnf(env.as_nzenv())
         }
         ExprKind::BoolLit(_) => builtin_to_value(Builtin::Bool),
         ExprKind::NaturalLit(_) => builtin_to_value(Builtin::Natural),
@@ -108,25 +144,19 @@ fn type_one_layer(
             }
             text_type
         }
-
-        // ExprKind::EmptyListLit(t) => {
-        //     let arg = match &*t.as_whnf() {
-        //         ValueKind::AppliedBuiltin(Builtin::List, args, _)
-        //             if args.len() == 1 =>
-        //         {
-        //             args[0].clone()
-        //         }
-        //         _ => return mkerr("InvalidListType"),
-        //     };
-        //     RetWhole(Value::from_kind_and_type(
-        //         ValueKind::EmptyListLit(arg),
-        //         t.clone(),
-        //     ))
-        // }
+        ExprKind::EmptyListLit(t) => {
+            let t = t.normalize_whnf(env.as_nzenv());
+            match &*t.as_whnf() {
+                ValueKind::AppliedBuiltin(Builtin::List, args, _)
+                    if args.len() == 1 => {}
+                _ => return mkerr("InvalidListType"),
+            };
+            t
+        }
         ExprKind::NEListLit(xs) => {
-            let mut iter = xs.iter().enumerate();
-            let (_, x) = iter.next().unwrap();
-            for (i, y) in iter {
+            let mut iter = xs.iter();
+            let x = iter.next().unwrap();
+            for y in iter {
                 if x.get_type()? != y.get_type()? {
                     return mkerr("InvalidListElement");
                 }
@@ -146,42 +176,96 @@ fn type_one_layer(
 
             Value::from_builtin(Builtin::Optional).app(t)
         }
-        // ExprKind::RecordType(kts) => RetWhole(tck_record_type(
-        //     kts.iter().map(|(x, t)| Ok((x.clone(), t.clone()))),
-        // )?),
-        // ExprKind::UnionType(kts) => RetWhole(tck_union_type(
-        //     kts.iter().map(|(x, t)| Ok((x.clone(), t.clone()))),
-        // )?),
-        // ExprKind::RecordLit(kvs) => RetTypeOnly(tck_record_type(
-        //     kvs.iter().map(|(x, v)| Ok((x.clone(), v.get_type()?))),
-        // )?),
-        ExprKind::Field(r, x) => {
-            match &*r.get_type()?.as_whnf() {
+        ExprKind::RecordLit(kvs) => {
+            use std::collections::hash_map::Entry;
+            let mut kts = HashMap::new();
+            for (x, v) in kvs {
+                // Check for duplicated entries
+                match kts.entry(x.clone()) {
+                    Entry::Occupied(_) => {
+                        return mkerr("RecordTypeDuplicateField")
+                    }
+                    Entry::Vacant(e) => e.insert(v.get_type()?),
+                };
+            }
+
+            let ty = type_of_recordtype(
+                kts.iter()
+                    .map(|(_, t)| Cow::Owned(t.to_tyexpr(env.as_quoteenv()))),
+            )?;
+            Value::from_kind_and_type(ValueKind::RecordType(kts), ty)
+        }
+        ExprKind::RecordType(kts) => {
+            use std::collections::hash_map::Entry;
+            let mut seen_fields = HashMap::new();
+            for (x, _) in kts {
+                // Check for duplicated entries
+                match seen_fields.entry(x.clone()) {
+                    Entry::Occupied(_) => {
+                        return mkerr("RecordTypeDuplicateField")
+                    }
+                    Entry::Vacant(e) => e.insert(()),
+                };
+            }
+
+            type_of_recordtype(kts.iter().map(|(_, t)| Cow::Borrowed(t)))?
+        }
+        ExprKind::UnionType(kts) => {
+            use std::collections::hash_map::Entry;
+            let mut seen_fields = HashMap::new();
+            // Check that all types are the same const
+            let mut k = None;
+            for (x, t) in kts {
+                if let Some(t) = t {
+                    match (k, t.get_type()?.as_const()) {
+                        (None, Some(k2)) => k = Some(k2),
+                        (Some(k1), Some(k2)) if k1 == k2 => {}
+                        _ => return mkerr("InvalidFieldType"),
+                    }
+                }
+                match seen_fields.entry(x) {
+                    Entry::Occupied(_) => {
+                        return mkerr("UnionTypeDuplicateField")
+                    }
+                    Entry::Vacant(e) => e.insert(()),
+                };
+            }
+
+            // An empty union type has type Type;
+            // an union type with only unary variants also has type Type
+            let k = k.unwrap_or(Const::Type);
+
+            Value::from_const(k)
+        }
+        ExprKind::Field(scrut, x) => {
+            match &*scrut.get_type()?.as_whnf() {
                 ValueKind::RecordType(kts) => match kts.get(&x) {
                     Some(tth) => tth.clone(),
                     None => return mkerr("MissingRecordField"),
                 },
-                // TODO: branch here only when r.get_type() is a Const
+                // TODO: branch here only when scrut.get_type() is a Const
                 _ => {
-                    let r_nf = r.normalize_whnf(env.as_nzenv());
-                    let r_nf_borrow = r_nf.as_whnf();
-                    match &*r_nf_borrow {
+                    let scrut_nf = scrut.normalize_whnf(env.as_nzenv());
+                    let scrut_nf_borrow = scrut_nf.as_whnf();
+                    match &*scrut_nf_borrow {
                         ValueKind::UnionType(kts) => match kts.get(x) {
                             // Constructor has type T -> < x: T, ... >
-                            // TODO: check pi type properly
-                            Some(Some(t)) => Value::from_kind_and_type(
+                            Some(Some(ty)) => Value::from_kind_and_type(
                                 ValueKind::PiClosure {
                                     binder: Binder::new(x.clone()),
-                                    annot: t.clone(),
+                                    annot: ty.clone(),
                                     closure: Closure::new(
-                                        t.clone(),
+                                        ty.clone(),
                                         env.as_nzenv(),
-                                        r.clone(),
+                                        scrut.clone(),
                                     ),
                                 },
-                                Value::from_const(Const::Type),
+                                type_of_function(
+                                    ty.get_type()?,
+                                    scrut.get_type()?,
+                                )?,
                             ),
-                            Some(None) => r_nf.clone(),
+                            Some(None) => scrut_nf.clone(),
                             None => return mkerr("MissingUnionField"),
                         },
                         _ => return mkerr("NotARecord"),
@@ -190,28 +274,45 @@ fn type_one_layer(
             }
         }
         ExprKind::Annot(x, t) => {
-            if x.get_type()? != t.normalize_whnf(env.as_nzenv()) {
+            let t = t.normalize_whnf(env.as_nzenv());
+            if x.get_type()? != t {
                 return mkerr("annot mismatch");
             }
-            x.normalize_whnf(env.as_nzenv())
+            t
         }
         ExprKind::App(f, arg) => {
             let tf = f.get_type()?;
             let tf_borrow = tf.as_whnf();
-            let (expected_arg_ty, ty_closure) = match &*tf_borrow {
-                ValueKind::PiClosure { annot, closure, .. } => (annot, closure),
+            match &*tf_borrow {
+                // ValueKind::PiClosure { annot, closure, .. } => (annot, closure),
+                ValueKind::PiClosure {
+                    annot: _expected_arg_ty,
+                    closure: ty_closure,
+                    ..
+                } => {
+                    // if arg.get_type()? != *expected_arg_ty {
+                    //     return mkerr(format!(
+                    //         "function annot mismatch: {:?}, {:?}",
+                    //         arg.get_type()?,
+                    //         expected_arg_ty
+                    //     ));
+                    // }
+
+                    let arg_nf = arg.normalize_whnf(env.as_nzenv());
+                    ty_closure.apply(arg_nf)
+                }
+                // ValueKind::Pi(_, _expected_arg_ty, body) => {
+                //     // if arg.get_type()? != *tx {
+                //     //     return mkerr("TypeMismatch");
+                //     // }
+
+                //     let arg_nf = arg.normalize_whnf(env.as_nzenv());
+                //     let ret = body.subst_shift(&AlphaVar::default(), &arg_nf);
+                //     ret.normalize_nf();
+                //     ret
+                // }
                 _ => return mkerr(format!("apply to not Pi: {:?}", tf_borrow)),
-            };
-            // if arg.get_type()? != *expected_arg_ty {
-            //     return mkerr(format!(
-            //         "function annot mismatch: {:?}, {:?}",
-            //         arg.get_type()?,
-            //         expected_arg_ty
-            //     ));
-            // }
-
-            let arg_nf = arg.normalize_whnf(env.as_nzenv());
-            ty_closure.apply(arg_nf)
+            }
         }
         ExprKind::BoolIf(x, y, z) => {
             if *x.get_type()?.as_whnf()
@@ -231,83 +332,63 @@ fn type_one_layer(
 
             y.get_type()?
         }
-        // ExprKind::BinOp(BinOp::RightBiasedRecordMerge, l, r) => {
-        //     let l_type = l.get_type()?;
-        //     let r_type = r.get_type()?;
-
-        //     // Extract the LHS record type
-        //     let l_type_borrow = l_type.as_whnf();
-        //     let kts_x = match &*l_type_borrow {
-        //         ValueKind::RecordType(kts) => kts,
-        //         _ => return mkerr("MustCombineRecord"),
-        //     };
-
-        //     // Extract the RHS record type
-        //     let r_type_borrow = r_type.as_whnf();
-        //     let kts_y = match &*r_type_borrow {
-        //         ValueKind::RecordType(kts) => kts,
-        //         _ => return mkerr("MustCombineRecord"),
-        //     };
+        ExprKind::BinOp(BinOp::RightBiasedRecordMerge, x, y) => {
+            let x_type = x.get_type()?;
+            let y_type = y.get_type()?;
 
-        //     // Union the two records, prefering
-        //     // the values found in the RHS.
-        //     let kts = merge_maps::<_, _, _, !>(kts_x, kts_y, |_, _, r_t| {
-        //         Ok(r_t.clone())
-        //     })?;
+            // Extract the LHS record type
+            let x_type_borrow = x_type.as_whnf();
+            let kts_x = match &*x_type_borrow {
+                ValueKind::RecordType(kts) => kts,
+                _ => return mkerr("MustCombineRecord"),
+            };
 
-        //     // Construct the final record type from the union
-        //     RetTypeOnly(tck_record_type(
-        //         kts.into_iter().map(|(x, v)| Ok((x.clone(), v))),
-        //     )?)
-        // }
-        // ExprKind::BinOp(BinOp::RecursiveRecordMerge, l, r) => RetTypeOnly(type_last_layer(
-        //     ctx,
-        //     ExprKind::BinOp(
-        //         RecursiveRecordTypeMerge,
-        //         l.get_type()?,
-        //         r.get_type()?,
-        //     ),
-        //     Span::Artificial,
-        // )?),
-        // ExprKind::BinOp(BinOp::RecursiveRecordTypeMerge, l, r) => {
-        //     // Extract the LHS record type
-        //     let borrow_l = l.as_whnf();
-        //     let kts_x = match &*borrow_l {
-        //         ValueKind::RecordType(kts) => kts,
-        //         _ => {
-        //             return mkerr("RecordTypeMergeRequiresRecordType")
-        //         }
-        //     };
+            // Extract the RHS record type
+            let y_type_borrow = y_type.as_whnf();
+            let kts_y = match &*y_type_borrow {
+                ValueKind::RecordType(kts) => kts,
+                _ => return mkerr("MustCombineRecord"),
+            };
 
-        //     // Extract the RHS record type
-        //     let borrow_r = r.as_whnf();
-        //     let kts_y = match &*borrow_r {
-        //         ValueKind::RecordType(kts) => kts,
-        //         _ => {
-        //             return mkerr("RecordTypeMergeRequiresRecordType")
-        //         }
-        //     };
+            // Union the two records, prefering
+            // the values found in the RHS.
+            let kts = merge_maps::<_, _, _, !>(kts_x, kts_y, |_, _, r_t| {
+                Ok(r_t.clone())
+            })?;
 
-        //     // Ensure that the records combine without a type error
-        //     let kts = merge_maps(
-        //         kts_x,
-        //         kts_y,
-        //         // If the Label exists for both records, then we hit the recursive case.
-        //         |_, l: &Value, r: &Value| {
-        //             type_last_layer(
-        //                 ctx,
-        //                 ExprKind::BinOp(
-        //                     RecursiveRecordTypeMerge,
-        //                     l.clone(),
-        //                     r.clone(),
-        //                 ),
-        //                 Span::Artificial,
-        //             )
-        //         },
-        //     )?;
-
-        //     RetWhole(tck_record_type(kts.into_iter().map(Ok))?)
-        // }
+            // Construct the final record type
+            let ty = type_of_recordtype(
+                kts.iter()
+                    .map(|(_, t)| Cow::Owned(t.to_tyexpr(env.as_quoteenv()))),
+            )?;
+            Value::from_kind_and_type(ValueKind::RecordType(kts), ty)
+        }
+        ExprKind::BinOp(BinOp::RecursiveRecordMerge, x, y) => {
+            let ekind = ExprKind::BinOp(
+                BinOp::RecursiveRecordTypeMerge,
+                x.get_type()?.to_tyexpr(env.as_quoteenv()),
+                y.get_type()?.to_tyexpr(env.as_quoteenv()),
+            );
+            let ty = type_one_layer(env, &ekind)?;
+            TyExpr::new(TyExprKind::Expr(ekind), Some(ty), Span::Artificial)
+                .normalize_whnf(env.as_nzenv())
+        }
+        ExprKind::BinOp(BinOp::RecursiveRecordTypeMerge, x, y) => {
+            let x_val = x.normalize_whnf(env.as_nzenv());
+            let y_val = y.normalize_whnf(env.as_nzenv());
+            match &*x_val.as_whnf() {
+                ValueKind::RecordType(_) => {}
+                _ => return mkerr("RecordTypeMergeRequiresRecordType"),
+            }
+            match &*y_val.as_whnf() {
+                ValueKind::RecordType(_) => {}
+                _ => return mkerr("RecordTypeMergeRequiresRecordType"),
+            }
+            // A RecordType's type is always a const
+            let xk = x.get_type()?.as_const().unwrap();
+            let yk = y.get_type()?.as_const().unwrap();
+            Value::from_const(max(xk, yk))
+        }
         // ExprKind::BinOp(o @ BinOp::ListAppend, l, r) => {
         //     match &*l.get_type()?.as_whnf() {
         //         ValueKind::AppliedBuiltin(List, _, _) => {}
@@ -363,6 +444,122 @@ fn type_one_layer(
 
             t
         }
+        // ExprKind::Merge(record, union, type_annot) => {
+        //     let record_type = record.get_type()?;
+        //     let record_borrow = record_type.as_whnf();
+        //     let handlers = match &*record_borrow {
+        //         ValueKind::RecordType(kts) => kts,
+        //         _ => return mkerr("Merge1ArgMustBeRecord"),
+        //     };
+
+        //     let union_type = union.get_type()?;
+        //     let union_borrow = union_type.as_whnf();
+        //     let variants = match &*union_borrow {
+        //         ValueKind::UnionType(kts) => Cow::Borrowed(kts),
+        //         ValueKind::AppliedBuiltin(
+        //             syntax::Builtin::Optional,
+        //             args,
+        //             _,
+        //         ) if args.len() == 1 => {
+        //             let ty = &args[0];
+        //             let mut kts = HashMap::new();
+        //             kts.insert("None".into(), None);
+        //             kts.insert("Some".into(), Some(ty.clone()));
+        //             Cow::Owned(kts)
+        //         }
+        //         _ => return mkerr("Merge2ArgMustBeUnionOrOptional"),
+        //     };
+
+        //     let mut inferred_type = None;
+        //     for (x, handler_type) in handlers {
+        //         let handler_return_type =
+        //             match variants.get(x) {
+        //                 // Union alternative with type
+        //                 Some(Some(variant_type)) => {
+        //                     let handler_type_borrow = handler_type.as_whnf();
+        //                     let (tx, tb) = match &*handler_type_borrow {
+        //                         ValueKind::Pi(_, tx, tb) => (tx, tb),
+        //                         _ => return mkerr("NotAFunction"),
+        //                     };
+
+        //                     if variant_type != tx {
+        //                         return mkerr("TypeMismatch");
+        //                     }
+
+        //                     // Extract `tb` from under the binder. Fails if the variable was used
+        //                     // in `tb`.
+        //                     match tb.over_binder() {
+        //                         Some(x) => x,
+        //                         None => return mkerr(
+        //                             "MergeHandlerReturnTypeMustNotBeDependent",
+        //                         ),
+        //                     }
+        //                 }
+        //                 // Union alternative without type
+        //                 Some(None) => handler_type.clone(),
+        //                 None => return mkerr("MergeHandlerMissingVariant"),
+        //             };
+        //         match &inferred_type {
+        //             None => inferred_type = Some(handler_return_type),
+        //             Some(t) => {
+        //                 if t != &handler_return_type {
+        //                     return mkerr("MergeHandlerTypeMismatch");
+        //                 }
+        //             }
+        //         }
+        //     }
+        //     for x in variants.keys() {
+        //         if !handlers.contains_key(x) {
+        //             return mkerr("MergeVariantMissingHandler");
+        //         }
+        //     }
+
+        //     match (inferred_type, type_annot.as_ref()) {
+        //         (Some(t1), Some(t2)) => {
+        //             if &t1 != t2 {
+        //                 return mkerr("MergeAnnotMismatch");
+        //             }
+        //             RetTypeOnly(t1)
+        //         }
+        //         (Some(t), None) => RetTypeOnly(t),
+        //         (None, Some(t)) => RetTypeOnly(t.clone()),
+        //         (None, None) => return mkerr("MergeEmptyNeedsAnnotation"),
+        //     }
+        // }
+        ExprKind::ToMap(_, _) => unimplemented!("toMap"),
+        ExprKind::Projection(record, labels) => {
+            let record_type = record.get_type()?;
+            let record_type_borrow = record_type.as_whnf();
+            let kts = match &*record_type_borrow {
+                ValueKind::RecordType(kts) => kts,
+                _ => return mkerr("ProjectionMustBeRecord"),
+            };
+
+            let mut new_kts = HashMap::new();
+            for l in labels {
+                match kts.get(l) {
+                    None => return mkerr("ProjectionMissingEntry"),
+                    Some(t) => {
+                        use std::collections::hash_map::Entry;
+                        match new_kts.entry(l.clone()) {
+                            Entry::Occupied(_) => {
+                                return mkerr("ProjectionDuplicateField")
+                            }
+                            Entry::Vacant(e) => e.insert(t.clone()),
+                        }
+                    }
+                };
+            }
+
+            Value::from_kind_and_type(
+                ValueKind::RecordType(new_kts),
+                record_type.get_type()?,
+            )
+        }
+        ExprKind::ProjectionByExpr(_, _) => {
+            unimplemented!("selection by expression")
+        }
+        ExprKind::Completion(_, _) => unimplemented!("record completion"),
         _ => Value::from_const(Const::Type), // TODO
     })
 }
@@ -383,18 +580,17 @@ fn type_with(
             let annot_nf = annot.normalize_whnf(env.as_nzenv());
             let body =
                 type_with(&env.insert_type(&binder, annot_nf.clone()), body)?;
-            let ty = Value::from_kind_and_type(
-                ValueKind::PiClosure {
-                    binder: Binder::new(binder.clone()),
-                    annot: annot_nf.clone(),
-                    closure: Closure::new(
-                        annot_nf,
-                        env.as_nzenv(),
-                        body.get_type()?.to_tyexpr(env.as_quoteenv().insert()),
-                    ),
-                },
-                Value::from_const(Const::Type), // TODO: function_check
+            let body_ty = body.get_type()?;
+            let ty = TyExpr::new(
+                TyExprKind::Expr(ExprKind::Pi(
+                    binder.clone(),
+                    annot.clone(),
+                    body_ty.to_tyexpr(env.as_quoteenv().insert()),
+                )),
+                Some(type_of_function(annot.get_type()?, body_ty.get_type()?)?),
+                Span::Artificial,
             );
+            let ty = ty.normalize_whnf(env.as_nzenv());
             (
                 TyExprKind::Expr(ExprKind::Lam(binder.clone(), annot, body)),
                 Some(ty),
@@ -405,19 +601,20 @@ fn type_with(
             let annot_nf = annot.normalize_whnf(env.as_nzenv());
             let body =
                 type_with(&env.insert_type(binder, annot_nf.clone()), body)?;
+            let ty = type_of_function(annot.get_type()?, body.get_type()?)?;
             (
                 TyExprKind::Expr(ExprKind::Pi(binder.clone(), annot, body)),
-                Some(Value::from_const(Const::Type)), // TODO: function_check
+                Some(ty),
             )
         }
         ExprKind::Let(binder, annot, val, body) => {
-            let v = if let Some(t) = annot {
+            let val = if let Some(t) = annot {
                 t.rewrap(ExprKind::Annot(val.clone(), t.clone()))
             } else {
                 val.clone()
             };
 
-            let val = type_with(env, val)?;
+            let val = type_with(env, &val)?;
             let val_nf = val.normalize_whnf(&env.as_nzenv());
             let body = type_with(&env.insert_value(&binder, val_nf), body)?;
             let body_ty = body.get_type().ok();
-- 
cgit v1.2.3


From 5a835d9db35bf76858e178e1bd66e60128879629 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 27 Jan 2020 18:45:09 +0000
Subject: Fix a bunch of bugs and more tck

---
 dhall/src/semantics/core/var.rs        |  8 ++++-
 dhall/src/semantics/nze/nzexpr.rs      | 24 +++++++++----
 dhall/src/semantics/phase/mod.rs       |  5 +++
 dhall/src/semantics/phase/normalize.rs |  5 ++-
 dhall/src/semantics/phase/resolve.rs   |  8 +++--
 dhall/src/semantics/phase/typecheck.rs | 26 ++++++++------
 dhall/src/semantics/tck/tyexpr.rs      | 10 ++++++
 dhall/src/semantics/tck/typecheck.rs   | 64 +++++++++++++++++++---------------
 dhall/src/tests.rs                     | 11 +++---
 9 files changed, 104 insertions(+), 57 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index 0d2c1d4..cf45d5e 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -1,10 +1,16 @@
 use crate::syntax::{Label, V};
 
 /// Stores an alpha-normalized variable.
-#[derive(Clone, Copy, PartialEq, Eq)]
+#[derive(Clone, Copy, Eq)]
 pub struct AlphaVar {
     alpha: V<()>,
 }
+// TODO: temporary hopefully
+impl std::cmp::PartialEq for AlphaVar {
+    fn eq(&self, _other: &Self) -> bool {
+        true
+    }
+}
 
 // Exactly like a Label, but equality returns always true.
 // This is so that ValueKind equality is exactly alpha-equivalence.
diff --git a/dhall/src/semantics/nze/nzexpr.rs b/dhall/src/semantics/nze/nzexpr.rs
index 49aa704..33fdde3 100644
--- a/dhall/src/semantics/nze/nzexpr.rs
+++ b/dhall/src/semantics/nze/nzexpr.rs
@@ -82,16 +82,16 @@ pub(crate) struct QuoteEnv {
 }
 
 // Reverse-debruijn index: counts number of binders from the bottom of the stack.
-#[derive(Debug, Clone, Copy, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) struct NzVar {
     idx: usize,
 }
 // TODO: temporary hopefully
-impl std::cmp::PartialEq for NzVar {
-    fn eq(&self, _other: &Self) -> bool {
-        true
-    }
-}
+// impl std::cmp::PartialEq for NzVar {
+//     fn eq(&self, _other: &Self) -> bool {
+//         true
+//     }
+// }
 
 impl TyEnv {
     pub fn new() -> Self {
@@ -144,6 +144,9 @@ impl NameEnv {
             size: self.names.len(),
         }
     }
+    pub fn names(&self) -> &[Binder] {
+        &self.names
+    }
 
     pub fn insert(&self, x: &Binder) -> Self {
         let mut env = self.clone();
@@ -220,13 +223,20 @@ impl QuoteEnv {
     pub fn construct(size: usize) -> Self {
         QuoteEnv { size }
     }
+    pub fn size(&self) -> usize {
+        self.size
+    }
     pub fn insert(&self) -> Self {
         QuoteEnv {
             size: self.size + 1,
         }
     }
     pub fn lookup(&self, var: &NzVar) -> AlphaVar {
-        AlphaVar::new(V((), self.size - var.idx - 1))
+        self.lookup_fallible(var).unwrap()
+    }
+    pub fn lookup_fallible(&self, var: &NzVar) -> Option<AlphaVar> {
+        let idx = self.size.checked_sub(var.idx + 1)?;
+        Some(AlphaVar::new(V((), idx)))
     }
 }
 
diff --git a/dhall/src/semantics/phase/mod.rs b/dhall/src/semantics/phase/mod.rs
index 4dc91e7..67cdc91 100644
--- a/dhall/src/semantics/phase/mod.rs
+++ b/dhall/src/semantics/phase/mod.rs
@@ -89,6 +89,11 @@ impl Resolved {
     pub fn to_expr(&self) -> ResolvedExpr {
         self.0.clone()
     }
+    pub fn tck_and_normalize_new_flow(&self) -> Result<Normalized, TypeError> {
+        let val = crate::semantics::tck::typecheck::typecheck(&self.0)?
+            .normalize_whnf_noenv();
+        Ok(Normalized(Typed(val)))
+    }
 }
 
 impl Typed {
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index 33e1f2b..5fc72fc 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -2,7 +2,7 @@
 use std::collections::HashMap;
 use std::convert::TryInto;
 
-use crate::semantics::nze::NzVar;
+use crate::semantics::nze::{NzVar, QuoteEnv};
 use crate::semantics::phase::typecheck::{
     builtin_to_value, const_to_value, rc, typecheck,
 };
@@ -859,6 +859,9 @@ impl NzEnv {
     pub fn construct(items: Vec<NzEnvItem>) -> Self {
         NzEnv { items }
     }
+    pub fn as_quoteenv(&self) -> QuoteEnv {
+        QuoteEnv::construct(self.items.len())
+    }
 
     pub fn insert_type(&self, t: Value) -> Self {
         let mut env = self.clone();
diff --git a/dhall/src/semantics/phase/resolve.rs b/dhall/src/semantics/phase/resolve.rs
index cc4a024..64106aa 100644
--- a/dhall/src/semantics/phase/resolve.rs
+++ b/dhall/src/semantics/phase/resolve.rs
@@ -52,10 +52,14 @@ fn load_import(
     import_cache: &mut ImportCache,
     import_stack: &ImportStack,
 ) -> Result<Normalized, Error> {
+    // Ok(
+    //     do_resolve_expr(Parsed::parse_file(f)?, import_cache, import_stack)?
+    //         .typecheck()?
+    //         .normalize(),
+    // )
     Ok(
         do_resolve_expr(Parsed::parse_file(f)?, import_cache, import_stack)?
-            .typecheck()?
-            .normalize(),
+            .tck_and_normalize_new_flow()?,
     )
 }
 
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index 1aab736..18e70e4 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -280,7 +280,9 @@ pub(crate) fn type_of_builtin<E>(b: Builtin) -> Expr<E> {
 pub(crate) fn builtin_to_value(b: Builtin) -> Value {
     Value::from_kind_and_type(
         ValueKind::from_builtin(b),
-        typecheck(type_of_builtin(b)).unwrap(),
+        crate::semantics::tck::typecheck::typecheck(&type_of_builtin(b))
+            .unwrap()
+            .normalize_whnf_noenv(),
     )
 }
 
@@ -380,17 +382,21 @@ fn type_last_layer(
         ExprKind::App(f, a) => {
             let tf = f.get_type()?;
             let tf_borrow = tf.as_whnf();
-            let (tx, tb) = match &*tf_borrow {
-                ValueKind::Pi(_, tx, tb) => (tx, tb),
+            match &*tf_borrow {
+                ValueKind::Pi(_, tx, tb) => {
+                    if &a.get_type()? != tx {
+                        return mkerr("TypeMismatch");
+                    }
+
+                    let ret = tb.subst_shift(&AlphaVar::default(), a);
+                    ret.normalize_nf();
+                    RetTypeOnly(ret)
+                }
+                ValueKind::PiClosure { closure, .. } => {
+                    RetTypeOnly(closure.apply(a.clone()))
+                }
                 _ => return mkerr("NotAFunction"),
-            };
-            if &a.get_type()? != tx {
-                return mkerr("TypeMismatch");
             }
-
-            let ret = tb.subst_shift(&AlphaVar::default(), a);
-            ret.normalize_nf();
-            RetTypeOnly(ret)
         }
         ExprKind::Annot(x, t) => {
             if &x.get_type()? != t {
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index c8be3a3..a42265d 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -5,6 +5,7 @@ use crate::semantics::phase::normalize::{normalize_tyexpr_whnf, NzEnv};
 use crate::semantics::phase::typecheck::rc;
 use crate::semantics::phase::Normalized;
 use crate::semantics::phase::{NormalizedExpr, ToExprOptions};
+use crate::semantics::tck::typecheck::TyEnv;
 use crate::semantics::Value;
 use crate::syntax::{ExprKind, Label, Span, V};
 
@@ -48,6 +49,15 @@ impl TyExpr {
     pub fn to_expr(&self, opts: ToExprOptions) -> NormalizedExpr {
         tyexpr_to_expr(self, opts, &mut Vec::new())
     }
+    pub fn to_expr_tyenv(&self, env: &TyEnv) -> NormalizedExpr {
+        let opts = ToExprOptions {
+            normalize: true,
+            alpha: false,
+        };
+        let env = env.as_nameenv().names();
+        let mut env = env.iter().collect();
+        tyexpr_to_expr(self, opts, &mut env)
+    }
     // TODO: temporary hack
     pub fn to_value(&self) -> Value {
         todo!()
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index 1b64d28..4ca5d4d 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -275,10 +275,22 @@ fn type_one_layer(
         }
         ExprKind::Annot(x, t) => {
             let t = t.normalize_whnf(env.as_nzenv());
-            if x.get_type()? != t {
-                return mkerr("annot mismatch");
+            let x_ty = x.get_type()?;
+            if x_ty != t {
+                return mkerr(format!(
+                    "annot mismatch: ({} : {}) : {}",
+                    x.to_expr_tyenv(env),
+                    x_ty.to_tyexpr(env.as_quoteenv()).to_expr_tyenv(env),
+                    t.to_tyexpr(env.as_quoteenv()).to_expr_tyenv(env)
+                ));
+                // return mkerr(format!(
+                //     "annot mismatch: {} != {}",
+                //     x_ty.to_tyexpr(env.as_quoteenv()).to_expr_tyenv(env),
+                //     t.to_tyexpr(env.as_quoteenv()).to_expr_tyenv(env)
+                // ));
+                // return mkerr(format!("annot mismatch: {:#?} : {:#?}", x, t,));
             }
-            t
+            x_ty
         }
         ExprKind::App(f, arg) => {
             let tf = f.get_type()?;
@@ -389,35 +401,29 @@ fn type_one_layer(
             let yk = y.get_type()?.as_const().unwrap();
             Value::from_const(max(xk, yk))
         }
-        // ExprKind::BinOp(o @ BinOp::ListAppend, l, r) => {
-        //     match &*l.get_type()?.as_whnf() {
-        //         ValueKind::AppliedBuiltin(List, _, _) => {}
-        //         _ => return mkerr("BinOpTypeMismatch"),
-        //     }
-
-        //     if l.get_type()? != r.get_type()? {
-        //         return mkerr("BinOpTypeMismatch");
-        //     }
+        ExprKind::BinOp(BinOp::ListAppend, l, r) => {
+            let l_ty = l.get_type()?;
+            match &*l_ty.as_whnf() {
+                ValueKind::AppliedBuiltin(Builtin::List, _, _) => {}
+                _ => return mkerr("BinOpTypeMismatch"),
+            }
 
-        //     l.get_type()?
-        // }
-        // ExprKind::BinOp(BinOp::Equivalence, l, r) => {
-        //     if l.get_type()?.get_type()?.as_const() != Some(Const::Type) {
-        //         return mkerr("EquivalenceArgumentMustBeTerm");
-        //     }
-        //     if r.get_type()?.get_type()?.as_const() != Some(Const::Type) {
-        //         return mkerr("EquivalenceArgumentMustBeTerm");
-        //     }
+            if l_ty != r.get_type()? {
+                return mkerr("BinOpTypeMismatch");
+            }
 
-        //     if l.get_type()? != r.get_type()? {
-        //         return mkerr("EquivalenceTypeMismatch");
-        //     }
+            l_ty
+        }
+        ExprKind::BinOp(BinOp::Equivalence, l, r) => {
+            if l.get_type()? != r.get_type()? {
+                return mkerr("EquivalenceTypeMismatch");
+            }
+            if l.get_type()?.get_type()?.as_const() != Some(Const::Type) {
+                return mkerr("EquivalenceArgumentsMustBeTerms");
+            }
 
-        //     RetWhole(Value::from_kind_and_type(
-        //         ValueKind::Equivalence(l.clone(), r.clone()),
-        //         Value::from_const(Type),
-        //     ))
-        // }
+            Value::from_const(Const::Type)
+        }
         ExprKind::BinOp(o, l, r) => {
             let t = builtin_to_value(match o {
                 BinOp::BoolAnd
diff --git a/dhall/src/tests.rs b/dhall/src/tests.rs
index f51f6a8..88c09cc 100644
--- a/dhall/src/tests.rs
+++ b/dhall/src/tests.rs
@@ -232,13 +232,10 @@ pub fn run_test(test: Test<'_>) -> Result<()> {
             //         alpha: false,
             //         normalize: true,
             //     });
-            let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
-            let expr = crate::semantics::tck::typecheck::typecheck(&expr)?
-                .normalize_whnf_noenv()
-                .to_expr(crate::semantics::phase::ToExprOptions {
-                    alpha: false,
-                    normalize: true,
-                });
+            let expr = parse_file_str(&expr_file_path)?
+                .resolve()?
+                .tck_and_normalize_new_flow()?
+                .to_expr();
             let expected = parse_file_str(&expected_file_path)?.to_expr();
 
             assert_eq_display!(expr, expected);
-- 
cgit v1.2.3


From 6d655b1c457d1e6cc9363bfa1c0e3ffd7ff03721 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 27 Jan 2020 18:45:29 +0000
Subject: Start rewriting value comparison

---
 dhall/src/semantics/core/value.rs | 107 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 107 insertions(+)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index a19cb02..35913cf 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -692,12 +692,119 @@ impl Closure {
     pub fn apply(&self, val: Value) -> Value {
         self.body.normalize_whnf(&self.env.insert_value(val))
     }
+    pub fn apply_fresh(&self, env: QuoteEnv) -> Value {
+        let val = Value::from_kind_and_type(
+            ValueKind::Var(AlphaVar::default(), NzVar::new(env.size())),
+            self.arg_ty.clone(),
+        );
+        self.apply(val)
+    }
     pub fn normalize(&self) -> Value {
         self.body
             .normalize_whnf(&self.env.insert_type(self.arg_ty.clone()))
     }
 }
 
+/// Compare two values for equality modulo alpha/beta-equivalence.
+// TODO: use Rc comparison to shortcut on identical pointers
+fn equiv(val1: &Value, val2: &Value) -> bool {
+    struct ValueWithEnv<'v> {
+        val: &'v Value,
+        env: QuoteEnv,
+    }
+    impl<'v> PartialEq for ValueWithEnv<'v> {
+        fn eq(&self, other: &ValueWithEnv<'v>) -> bool {
+            equiv_with_env(self.env, self.val, other.env, other.val)
+        }
+    }
+    // Push the given context into every subnode of the ValueKind. That way, normal equality of the
+    // resulting value will take into account the context.
+    fn push_context<'v>(
+        env: QuoteEnv,
+        kind: &'v ValueKind<Value>,
+    ) -> ValueKind<ValueWithEnv<'v>> {
+        kind.map_ref_with_special_handling_of_binders(
+            |val| ValueWithEnv { val, env },
+            |_, _, val| ValueWithEnv {
+                val,
+                env: env.insert(),
+            },
+        )
+    }
+
+    fn equiv_with_env<'v>(
+        env1: QuoteEnv,
+        val1: &'v Value,
+        env2: QuoteEnv,
+        val2: &'v Value,
+    ) -> bool {
+        use ValueKind::Var;
+        let kind1 = val1.as_whnf();
+        let kind2 = val2.as_whnf();
+        match (&*kind1, &*kind2) {
+            (Var(_, v1), Var(_, v2)) => {
+                v1 == v2
+                // match (env1.lookup(v1), env2.lookup(v2)) {
+                //     // Both vars were found in the environment, check they point to the same
+                //     // binder.
+                //     // Does that even make any sense with an incomplete environment ?
+                //     // I have no clue what I'm doing anymore.
+                //     (Some(i), Some(j)) => i == j,
+                //     // Both vars point to outside the environment ????
+                //     // (None, None) => v1 == v2,
+                //     _ => false,
+                // }
+            }
+            // (Var(_, v1), Var(_, v2)) => env1.lookup(v1) == env2.lookup(v2),
+            (
+                ValueKind::LamClosure {
+                    annot: a1,
+                    closure: cl1,
+                    ..
+                },
+                ValueKind::LamClosure {
+                    annot: a2,
+                    closure: cl2,
+                    ..
+                },
+            ) => {
+                equiv_with_env(env1, a1, env2, a2)
+                    && equiv_with_env(
+                        env1.insert(),
+                        &cl1.apply_fresh(env1),
+                        env2.insert(),
+                        &cl2.apply_fresh(env2),
+                    )
+            }
+            (
+                ValueKind::PiClosure {
+                    annot: a1,
+                    closure: cl1,
+                    ..
+                },
+                ValueKind::PiClosure {
+                    annot: a2,
+                    closure: cl2,
+                    ..
+                },
+            ) => {
+                equiv_with_env(env1, a1, env2, a2)
+                    && equiv_with_env(
+                        env1.insert(),
+                        &cl1.apply_fresh(env1),
+                        env2.insert(),
+                        &cl2.apply_fresh(env2),
+                    )
+            }
+            (k1, k2) => push_context(env1, k1) == push_context(env2, k2),
+        }
+    }
+
+    // TODO: need to use ambiant env instead of creating new one
+    // Might be possible to generate free variables differently to avoid this
+    equiv_with_env(QuoteEnv::new(), val1, QuoteEnv::new(), val2)
+}
+
 // TODO: use Rc comparison to shortcut on identical pointers
 impl std::cmp::PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {
-- 
cgit v1.2.3


From 8ced62a2cdde95c4d67298289756c12f53656df0 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 28 Jan 2020 18:41:20 +0000
Subject: Fix all sorts of variable shenanigans

---
 dhall/src/semantics/core/value.rs | 118 ++++----------------------------------
 dhall/src/semantics/nze/nzexpr.rs |  34 ++++++++---
 dhall/src/semantics/tck/tyexpr.rs |  15 ++++-
 dhall/src/tests.rs                |  18 ++++++
 4 files changed, 68 insertions(+), 117 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 35913cf..42da653 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -303,7 +303,9 @@ impl Value {
             } => TyExprKind::Expr(ExprKind::Lam(
                 binder.to_label(),
                 annot.to_tyexpr(qenv),
-                closure.normalize().to_tyexpr(qenv.insert()),
+                closure
+                    .apply_var(NzVar::new(qenv.size()))
+                    .to_tyexpr(qenv.insert()),
             )),
             ValueKind::PiClosure {
                 binder,
@@ -312,7 +314,9 @@ impl Value {
             } => TyExprKind::Expr(ExprKind::Pi(
                 binder.to_label(),
                 annot.to_tyexpr(qenv),
-                closure.normalize().to_tyexpr(qenv.insert()),
+                closure
+                    .apply_var(NzVar::new(qenv.size()))
+                    .to_tyexpr(qenv.insert()),
             )),
             ValueKind::AppliedBuiltin(b, args, types) => {
                 TyExprKind::Expr(args.into_iter().zip(types.into_iter()).fold(
@@ -692,119 +696,16 @@ impl Closure {
     pub fn apply(&self, val: Value) -> Value {
         self.body.normalize_whnf(&self.env.insert_value(val))
     }
-    pub fn apply_fresh(&self, env: QuoteEnv) -> Value {
+    pub fn apply_var(&self, var: NzVar) -> Value {
         let val = Value::from_kind_and_type(
-            ValueKind::Var(AlphaVar::default(), NzVar::new(env.size())),
+            ValueKind::Var(AlphaVar::default(), var),
             self.arg_ty.clone(),
         );
         self.apply(val)
     }
-    pub fn normalize(&self) -> Value {
-        self.body
-            .normalize_whnf(&self.env.insert_type(self.arg_ty.clone()))
-    }
 }
 
 /// Compare two values for equality modulo alpha/beta-equivalence.
-// TODO: use Rc comparison to shortcut on identical pointers
-fn equiv(val1: &Value, val2: &Value) -> bool {
-    struct ValueWithEnv<'v> {
-        val: &'v Value,
-        env: QuoteEnv,
-    }
-    impl<'v> PartialEq for ValueWithEnv<'v> {
-        fn eq(&self, other: &ValueWithEnv<'v>) -> bool {
-            equiv_with_env(self.env, self.val, other.env, other.val)
-        }
-    }
-    // Push the given context into every subnode of the ValueKind. That way, normal equality of the
-    // resulting value will take into account the context.
-    fn push_context<'v>(
-        env: QuoteEnv,
-        kind: &'v ValueKind<Value>,
-    ) -> ValueKind<ValueWithEnv<'v>> {
-        kind.map_ref_with_special_handling_of_binders(
-            |val| ValueWithEnv { val, env },
-            |_, _, val| ValueWithEnv {
-                val,
-                env: env.insert(),
-            },
-        )
-    }
-
-    fn equiv_with_env<'v>(
-        env1: QuoteEnv,
-        val1: &'v Value,
-        env2: QuoteEnv,
-        val2: &'v Value,
-    ) -> bool {
-        use ValueKind::Var;
-        let kind1 = val1.as_whnf();
-        let kind2 = val2.as_whnf();
-        match (&*kind1, &*kind2) {
-            (Var(_, v1), Var(_, v2)) => {
-                v1 == v2
-                // match (env1.lookup(v1), env2.lookup(v2)) {
-                //     // Both vars were found in the environment, check they point to the same
-                //     // binder.
-                //     // Does that even make any sense with an incomplete environment ?
-                //     // I have no clue what I'm doing anymore.
-                //     (Some(i), Some(j)) => i == j,
-                //     // Both vars point to outside the environment ????
-                //     // (None, None) => v1 == v2,
-                //     _ => false,
-                // }
-            }
-            // (Var(_, v1), Var(_, v2)) => env1.lookup(v1) == env2.lookup(v2),
-            (
-                ValueKind::LamClosure {
-                    annot: a1,
-                    closure: cl1,
-                    ..
-                },
-                ValueKind::LamClosure {
-                    annot: a2,
-                    closure: cl2,
-                    ..
-                },
-            ) => {
-                equiv_with_env(env1, a1, env2, a2)
-                    && equiv_with_env(
-                        env1.insert(),
-                        &cl1.apply_fresh(env1),
-                        env2.insert(),
-                        &cl2.apply_fresh(env2),
-                    )
-            }
-            (
-                ValueKind::PiClosure {
-                    annot: a1,
-                    closure: cl1,
-                    ..
-                },
-                ValueKind::PiClosure {
-                    annot: a2,
-                    closure: cl2,
-                    ..
-                },
-            ) => {
-                equiv_with_env(env1, a1, env2, a2)
-                    && equiv_with_env(
-                        env1.insert(),
-                        &cl1.apply_fresh(env1),
-                        env2.insert(),
-                        &cl2.apply_fresh(env2),
-                    )
-            }
-            (k1, k2) => push_context(env1, k1) == push_context(env2, k2),
-        }
-    }
-
-    // TODO: need to use ambiant env instead of creating new one
-    // Might be possible to generate free variables differently to avoid this
-    equiv_with_env(QuoteEnv::new(), val1, QuoteEnv::new(), val2)
-}
-
 // TODO: use Rc comparison to shortcut on identical pointers
 impl std::cmp::PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {
@@ -815,7 +716,8 @@ impl std::cmp::Eq for Value {}
 
 impl std::cmp::PartialEq for Closure {
     fn eq(&self, other: &Self) -> bool {
-        self.normalize() == other.normalize()
+        let v = NzVar::fresh();
+        self.apply_var(v) == other.apply_var(v)
     }
 }
 impl std::cmp::Eq for Closure {}
diff --git a/dhall/src/semantics/nze/nzexpr.rs b/dhall/src/semantics/nze/nzexpr.rs
index 33fdde3..6559082 100644
--- a/dhall/src/semantics/nze/nzexpr.rs
+++ b/dhall/src/semantics/nze/nzexpr.rs
@@ -81,10 +81,12 @@ pub(crate) struct QuoteEnv {
     size: usize,
 }
 
-// Reverse-debruijn index: counts number of binders from the bottom of the stack.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) struct NzVar {
-    idx: usize,
+pub(crate) enum NzVar {
+    /// Reverse-debruijn index: counts number of binders from the bottom of the stack.
+    Bound(usize),
+    /// Fake fresh variable generated for expression equality checking.
+    Fresh(usize),
 }
 // TODO: temporary hopefully
 // impl std::cmp::PartialEq for NzVar {
@@ -207,7 +209,9 @@ impl NzEnv {
         let idx = self.items.len() - 1 - var.idx();
         match &self.items[idx] {
             NzEnvItem::Kept(ty) => NzExpr::new(
-                NzExprKind::Var { var: NzVar { idx } },
+                NzExprKind::Var {
+                    var: NzVar::new(idx),
+                },
                 Some(ty.clone()),
             ),
             NzEnvItem::Replaced(x) => x.clone(),
@@ -235,18 +239,32 @@ impl QuoteEnv {
         self.lookup_fallible(var).unwrap()
     }
     pub fn lookup_fallible(&self, var: &NzVar) -> Option<AlphaVar> {
-        let idx = self.size.checked_sub(var.idx + 1)?;
+        let idx = self.size.checked_sub(var.idx() + 1)?;
         Some(AlphaVar::new(V((), idx)))
     }
 }
 
 impl NzVar {
     pub fn new(idx: usize) -> Self {
-        NzVar { idx }
+        NzVar::Bound(idx)
+    }
+    pub fn fresh() -> Self {
+        use std::sync::atomic::{AtomicUsize, Ordering};
+        // Global counter to ensure uniqueness of the generated id.
+        static FRESH_VAR_COUNTER: AtomicUsize = AtomicUsize::new(0);
+        let id = FRESH_VAR_COUNTER.fetch_add(1, Ordering::SeqCst);
+        NzVar::Fresh(id)
     }
     pub fn shift(&self, delta: isize) -> Self {
-        NzVar {
-            idx: (self.idx as isize + delta) as usize,
+        NzVar::new((self.idx() as isize + delta) as usize)
+    }
+    // Panics on a fresh variable.
+    pub fn idx(&self) -> usize {
+        match self {
+            NzVar::Bound(i) => *i,
+            NzVar::Fresh(_) => panic!(
+                "Trying to use a fresh variable outside of equality checking"
+            ),
         }
     }
 }
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index a42265d..9e8dc47 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -12,7 +12,7 @@ use crate::syntax::{ExprKind, Label, Span, V};
 pub(crate) type Type = Value;
 
 // An expression with inferred types at every node and resolved variables.
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub(crate) struct TyExpr {
     kind: Box<TyExprKind>,
     ty: Option<Type>,
@@ -114,3 +114,16 @@ fn tyexpr_to_expr<'a>(
         }
     })
 }
+
+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()
+    }
+}
diff --git a/dhall/src/tests.rs b/dhall/src/tests.rs
index 88c09cc..971c48d 100644
--- a/dhall/src/tests.rs
+++ b/dhall/src/tests.rs
@@ -164,6 +164,7 @@ pub fn run_test(test: Test<'_>) -> Result<()> {
             // let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
             // let tyexpr = crate::semantics::nze::nzexpr::typecheck(expr)?;
             // let ty = tyexpr.get_type()?.to_expr();
+            //
             let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
             let ty = crate::semantics::tck::typecheck::typecheck(&expr)?
                 .get_type()?
@@ -173,6 +174,23 @@ pub fn run_test(test: Test<'_>) -> Result<()> {
                 });
             let expected = parse_file_str(&expected_file_path)?.to_expr();
             assert_eq_display!(ty, expected);
+            //
+            // let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
+            // let ty = crate::semantics::tck::typecheck::typecheck(&expr)?
+            //     .get_type()?;
+            // let expected = parse_file_str(&expected_file_path)?.to_expr();
+            // let expected = crate::semantics::tck::typecheck::typecheck(&expected)?
+            //     .normalize_whnf_noenv();
+            // // if ty != expected {
+            // //     assert_eq_display!(ty.to_expr(crate::semantics::phase::ToExprOptions {
+            // //         alpha: false,
+            // //         normalize: true,
+            // //     }), expected.to_expr(crate::semantics::phase::ToExprOptions {
+            // //         alpha: false,
+            // //         normalize: true,
+            // //     }))
+            // // }
+            // assert_eq_pretty!(ty, expected);
         }
         TypeInferenceFailure(file_path) => {
             let mut res =
-- 
cgit v1.2.3


From 084e81956e99bc759012be7c171f4095c2e59d22 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 28 Jan 2020 19:34:11 +0000
Subject: Thread env through nztion to fix Foo/build closures

---
 dhall/build.rs                         |  7 ----
 dhall/src/semantics/core/value.rs      | 21 +++++++---
 dhall/src/semantics/core/visitor.rs    |  9 +++--
 dhall/src/semantics/nze/nzexpr.rs      |  5 +++
 dhall/src/semantics/phase/normalize.rs | 70 ++++++++++++++++++++++------------
 dhall/src/semantics/phase/typecheck.rs | 20 ++++++----
 dhall/src/semantics/tck/typecheck.rs   | 14 +++++--
 7 files changed, 95 insertions(+), 51 deletions(-)

(limited to 'dhall')

diff --git a/dhall/build.rs b/dhall/build.rs
index ed8d98b..c95a26d 100644
--- a/dhall/build.rs
+++ b/dhall/build.rs
@@ -276,13 +276,6 @@ fn generate_tests() -> std::io::Result<()> {
                     // TODO: record completion
                     || path == "simple/completion"
                     || path == "unit/Completion"
-                    // TODO: fix variables in Foo/build
-                    || path == "unit/ListBuildFoldFusion"
-                    || path == "unit/ListBuildImplementation"
-                    || path == "unit/NaturalBuildFoldFusion"
-                    || path == "unit/NaturalBuildImplementation"
-                    || path == "unit/OptionalBuildFoldFusion"
-                    || path == "unit/OptionalBuildImplementation"
             }),
             input_type: FileType::Text,
             output_type: Some(FileType::Text),
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 42da653..71c5c65 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -6,7 +6,9 @@ use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::var::{AlphaVar, Binder};
 use crate::semantics::nze::{NzVar, QuoteEnv};
 use crate::semantics::phase::normalize::{apply_any, normalize_whnf, NzEnv};
-use crate::semantics::phase::typecheck::{builtin_to_value, const_to_value};
+use crate::semantics::phase::typecheck::{
+    builtin_to_value, builtin_to_value_env, const_to_value,
+};
 use crate::semantics::phase::{
     Normalized, NormalizedExpr, ToExprOptions, Typed,
 };
@@ -77,7 +79,8 @@ pub(crate) enum ValueKind<Value> {
     },
     // Invariant: in whnf, the evaluation must not be able to progress further.
     // Keep types around to be able to recover the types of partial applications.
-    AppliedBuiltin(Builtin, Vec<Value>, Vec<Value>),
+    // Keep env around to construct Foo/build closures; hopefully temporary.
+    AppliedBuiltin(Builtin, Vec<Value>, Vec<Value>, NzEnv),
 
     Var(AlphaVar, NzVar),
     Const(Const),
@@ -144,7 +147,10 @@ impl Value {
         const_to_value(c)
     }
     pub(crate) fn from_builtin(b: Builtin) -> Self {
-        builtin_to_value(b)
+        Self::from_builtin_env(b, &NzEnv::new())
+    }
+    pub(crate) fn from_builtin_env(b: Builtin, env: &NzEnv) -> Self {
+        builtin_to_value_env(b, env)
     }
     pub(crate) fn with_span(self, span: Span) -> Self {
         self.as_internal_mut().span = span;
@@ -318,7 +324,7 @@ impl Value {
                     .apply_var(NzVar::new(qenv.size()))
                     .to_tyexpr(qenv.insert()),
             )),
-            ValueKind::AppliedBuiltin(b, args, types) => {
+            ValueKind::AppliedBuiltin(b, args, types, _) => {
                 TyExprKind::Expr(args.into_iter().zip(types.into_iter()).fold(
                     ExprKind::Builtin(*b),
                     |acc, (v, ty)| {
@@ -561,7 +567,7 @@ impl ValueKind<Value> {
             | ValueKind::PiClosure { annot, .. } => {
                 annot.normalize_mut();
             }
-            ValueKind::AppliedBuiltin(_, args, _) => {
+            ValueKind::AppliedBuiltin(_, args, _, _) => {
                 for x in args.iter_mut() {
                     x.normalize_mut();
                 }
@@ -609,7 +615,10 @@ impl ValueKind<Value> {
     }
 
     pub(crate) fn from_builtin(b: Builtin) -> ValueKind<Value> {
-        ValueKind::AppliedBuiltin(b, vec![], vec![])
+        ValueKind::from_builtin_env(b, NzEnv::new())
+    }
+    pub(crate) fn from_builtin_env(b: Builtin, env: NzEnv) -> ValueKind<Value> {
+        ValueKind::AppliedBuiltin(b, vec![], vec![], env)
     }
 
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
diff --git a/dhall/src/semantics/core/visitor.rs b/dhall/src/semantics/core/visitor.rs
index 64250b0..61a7d0b 100644
--- a/dhall/src/semantics/core/visitor.rs
+++ b/dhall/src/semantics/core/visitor.rs
@@ -98,9 +98,12 @@ where
             annot: v.visit_val(annot)?,
             closure: closure.clone(),
         },
-        AppliedBuiltin(b, xs, types) => {
-            AppliedBuiltin(*b, v.visit_vec(xs)?, v.visit_vec(types)?)
-        }
+        AppliedBuiltin(b, xs, types, env) => AppliedBuiltin(
+            *b,
+            v.visit_vec(xs)?,
+            v.visit_vec(types)?,
+            env.clone(),
+        ),
         Var(v, w) => Var(v.clone(), *w),
         Const(k) => Const(*k),
         BoolLit(b) => BoolLit(*b),
diff --git a/dhall/src/semantics/nze/nzexpr.rs b/dhall/src/semantics/nze/nzexpr.rs
index 6559082..92ba8fd 100644
--- a/dhall/src/semantics/nze/nzexpr.rs
+++ b/dhall/src/semantics/nze/nzexpr.rs
@@ -141,6 +141,11 @@ impl NameEnv {
     pub fn new() -> Self {
         NameEnv { names: Vec::new() }
     }
+    pub fn from_binders(names: impl Iterator<Item = Binder>) -> Self {
+        NameEnv {
+            names: names.collect(),
+        }
+    }
     pub fn as_quoteenv(&self) -> QuoteEnv {
         QuoteEnv {
             size: self.names.len(),
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index 5fc72fc..a11cb75 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -4,9 +4,11 @@ use std::convert::TryInto;
 
 use crate::semantics::nze::{NzVar, QuoteEnv};
 use crate::semantics::phase::typecheck::{
-    builtin_to_value, const_to_value, rc, typecheck,
+    builtin_to_value_env, const_to_value, rc,
 };
 use crate::semantics::phase::Normalized;
+use crate::semantics::tck::typecheck::type_with;
+use crate::semantics::tck::typecheck::TyEnv;
 use crate::semantics::{
     AlphaVar, Binder, Closure, TyExpr, TyExprKind, Value, ValueKind,
 };
@@ -73,6 +75,7 @@ pub(crate) fn apply_builtin(
     args: Vec<Value>,
     ty: &Value,
     types: Vec<Value>,
+    env: NzEnv,
 ) -> ValueKind<Value> {
     use syntax::Builtin::*;
     use ValueKind::*;
@@ -86,6 +89,11 @@ pub(crate) fn apply_builtin(
         ValueWithRemainingArgs(&'a [Value], Value),
         DoneAsIs,
     }
+    let make_closure = |e| {
+        type_with(&env.to_alpha_tyenv(), &e)
+            .unwrap()
+            .normalize_whnf(&env)
+    };
 
     let ret = match (b, args.as_slice()) {
         (OptionalNone, [t]) => Ret::ValueKind(EmptyOptionalLit(t.clone())),
@@ -272,13 +280,12 @@ pub(crate) fn apply_builtin(
             Ret::Value(
                 f.app(list_t.clone())
                     .app(
-                        typecheck(make_closure!(
+                        make_closure(make_closure!(
                             λ(T : Type) ->
                             λ(a : var(T)) ->
                             λ(as : List var(T)) ->
                             [ var(a) ] # var(as)
                         ))
-                        .unwrap()
                         .app(t.clone()),
                     )
                     .app(EmptyListLit(t.clone()).into_value_with_type(list_t)),
@@ -300,12 +307,11 @@ pub(crate) fn apply_builtin(
             Ret::Value(
                 f.app(optional_t.clone())
                     .app(
-                        typecheck(make_closure!(
+                        make_closure(make_closure!(
                             λ(T : Type) ->
                             λ(a : var(T)) ->
                             Some(var(a))
                         ))
-                        .unwrap()
                         .app(t.clone()),
                     )
                     .app(
@@ -326,13 +332,10 @@ pub(crate) fn apply_builtin(
         },
         (NaturalBuild, [f]) => Ret::Value(
             f.app(Value::from_builtin(Natural))
-                .app(
-                    typecheck(make_closure!(
-                        λ(x : Natural) ->
-                        1 + var(x)
-                    ))
-                    .unwrap(),
-                )
+                .app(make_closure(make_closure!(
+                    λ(x : Natural) ->
+                    1 + var(x)
+                )))
                 .app(
                     NaturalLit(0)
                         .into_value_with_type(Value::from_builtin(Natural)),
@@ -366,7 +369,7 @@ pub(crate) fn apply_builtin(
             }
             v.to_whnf_check_type(ty)
         }
-        Ret::DoneAsIs => AppliedBuiltin(b, args, types),
+        Ret::DoneAsIs => AppliedBuiltin(b, args, types, env),
     }
 }
 
@@ -379,7 +382,7 @@ pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
         ValueKind::LamClosure { closure, .. } => {
             closure.apply(a).to_whnf_check_type(ty)
         }
-        ValueKind::AppliedBuiltin(b, args, types) => {
+        ValueKind::AppliedBuiltin(b, args, types, env) => {
             use std::iter::once;
             let args = args.iter().cloned().chain(once(a.clone())).collect();
             let types = types
@@ -387,7 +390,7 @@ pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
                 .cloned()
                 .chain(once(f.get_type().unwrap()))
                 .collect();
-            apply_builtin(*b, args, ty, types)
+            apply_builtin(*b, args, ty, types, env.clone())
         }
         ValueKind::UnionConstructor(l, kts, uniont) => ValueKind::UnionLit(
             l.clone(),
@@ -625,6 +628,7 @@ fn apply_binop<'a>(
 pub(crate) fn normalize_one_layer(
     expr: ExprKind<Value, Normalized>,
     ty: &Value,
+    env: &NzEnv,
 ) -> ValueKind<Value> {
     use ValueKind::{
         BoolLit, DoubleLit, EmptyOptionalLit, IntegerLit, NEListLit,
@@ -649,7 +653,7 @@ pub(crate) fn normalize_one_layer(
         }
         ExprKind::Annot(x, _) => Ret::Value(x),
         ExprKind::Const(c) => Ret::Value(const_to_value(c)),
-        ExprKind::Builtin(b) => Ret::Value(builtin_to_value(b)),
+        ExprKind::Builtin(b) => Ret::Value(builtin_to_value_env(b, env)),
         ExprKind::Assert(_) => Ret::Expr(expr),
         ExprKind::App(v, a) => Ret::Value(v.app(a)),
         ExprKind::BoolLit(b) => Ret::ValueKind(BoolLit(b)),
@@ -659,11 +663,12 @@ pub(crate) fn normalize_one_layer(
         ExprKind::SomeLit(e) => Ret::ValueKind(NEOptionalLit(e)),
         ExprKind::EmptyListLit(t) => {
             let arg = match &*t.as_whnf() {
-                ValueKind::AppliedBuiltin(syntax::Builtin::List, args, _)
-                    if args.len() == 1 =>
-                {
-                    args[0].clone()
-                }
+                ValueKind::AppliedBuiltin(
+                    syntax::Builtin::List,
+                    args,
+                    _,
+                    _,
+                ) if args.len() == 1 => args[0].clone(),
                 _ => panic!("internal type error"),
             };
             Ret::ValueKind(ValueKind::EmptyListLit(arg))
@@ -827,10 +832,10 @@ pub(crate) fn normalize_whnf(
     ty: &Value,
 ) -> ValueKind<Value> {
     match v {
-        ValueKind::AppliedBuiltin(b, args, types) => {
-            apply_builtin(b, args, ty, types)
+        ValueKind::AppliedBuiltin(b, args, types, env) => {
+            apply_builtin(b, args, ty, types, env)
         }
-        ValueKind::PartialExpr(e) => normalize_one_layer(e, ty),
+        ValueKind::PartialExpr(e) => normalize_one_layer(e, ty, &NzEnv::new()),
         ValueKind::TextLit(elts) => {
             ValueKind::TextLit(squash_textlit(elts.into_iter()))
         }
@@ -862,6 +867,9 @@ impl NzEnv {
     pub fn as_quoteenv(&self) -> QuoteEnv {
         QuoteEnv::construct(self.items.len())
     }
+    pub fn to_alpha_tyenv(&self) -> TyEnv {
+        TyEnv::from_nzenv_alpha(self)
+    }
 
     pub fn insert_type(&self, t: Value) -> Self {
         let mut env = self.clone();
@@ -890,6 +898,10 @@ impl NzEnv {
             NzEnvItem::Replaced(x) => x.clone(),
         }
     }
+
+    pub fn size(&self) -> usize {
+        self.items.len()
+    }
 }
 
 /// Normalize a TyExpr into WHNF
@@ -924,10 +936,18 @@ pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> Value {
         }
         TyExprKind::Expr(e) => {
             let e = e.map_ref(|tye| tye.normalize_whnf(env));
-            normalize_one_layer(e, &ty)
+            normalize_one_layer(e, &ty, env)
         }
     };
 
     // dbg!(tye.kind(), env, &kind);
     Value::from_kind_and_type_whnf(kind, ty)
 }
+
+/// Ignore NzEnv when comparing
+impl std::cmp::PartialEq for NzEnv {
+    fn eq(&self, _other: &Self) -> bool {
+        true
+    }
+}
+impl std::cmp::Eq for NzEnv {}
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index 18e70e4..f559323 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -5,6 +5,7 @@ use std::collections::HashMap;
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::context::TyCtx;
 use crate::semantics::phase::normalize::merge_maps;
+use crate::semantics::phase::normalize::NzEnv;
 use crate::semantics::phase::Normalized;
 use crate::semantics::{AlphaVar, Binder, Value, ValueKind};
 use crate::syntax;
@@ -278,8 +279,11 @@ pub(crate) fn type_of_builtin<E>(b: Builtin) -> Expr<E> {
 }
 
 pub(crate) fn builtin_to_value(b: Builtin) -> Value {
+    builtin_to_value_env(b, &NzEnv::new())
+}
+pub(crate) fn builtin_to_value_env(b: Builtin, env: &NzEnv) -> Value {
     Value::from_kind_and_type(
-        ValueKind::from_builtin(b),
+        ValueKind::from_builtin_env(b, env.clone()),
         crate::semantics::tck::typecheck::typecheck(&type_of_builtin(b))
             .unwrap()
             .normalize_whnf_noenv(),
@@ -433,11 +437,12 @@ fn type_last_layer(
         }
         ExprKind::EmptyListLit(t) => {
             let arg = match &*t.as_whnf() {
-                ValueKind::AppliedBuiltin(syntax::Builtin::List, args, _)
-                    if args.len() == 1 =>
-                {
-                    args[0].clone()
-                }
+                ValueKind::AppliedBuiltin(
+                    syntax::Builtin::List,
+                    args,
+                    _,
+                    _,
+                ) if args.len() == 1 => args[0].clone(),
                 _ => return mkerr("InvalidListType"),
             };
             RetWhole(Value::from_kind_and_type(
@@ -596,7 +601,7 @@ fn type_last_layer(
         }
         ExprKind::BinOp(ListAppend, l, r) => {
             match &*l.get_type()?.as_whnf() {
-                ValueKind::AppliedBuiltin(List, _, _) => {}
+                ValueKind::AppliedBuiltin(List, _, _, _) => {}
                 _ => return mkerr("BinOpTypeMismatch"),
             }
 
@@ -666,6 +671,7 @@ fn type_last_layer(
                     syntax::Builtin::Optional,
                     args,
                     _,
+                    _,
                 ) if args.len() == 1 => {
                     let ty = &args[0];
                     let mut kts = HashMap::new();
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index 4ca5d4d..e2619b5 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -35,6 +35,14 @@ impl TyEnv {
             items: NzEnv::new(),
         }
     }
+    pub fn from_nzenv_alpha(items: &NzEnv) -> Self {
+        TyEnv {
+            names: NameEnv::from_binders(
+                std::iter::repeat("_".into()).take(items.size()),
+            ),
+            items: items.clone(),
+        }
+    }
     pub fn as_quoteenv(&self) -> QuoteEnv {
         self.names.as_quoteenv()
     }
@@ -147,7 +155,7 @@ fn type_one_layer(
         ExprKind::EmptyListLit(t) => {
             let t = t.normalize_whnf(env.as_nzenv());
             match &*t.as_whnf() {
-                ValueKind::AppliedBuiltin(Builtin::List, args, _)
+                ValueKind::AppliedBuiltin(Builtin::List, args, _, _)
                     if args.len() == 1 => {}
                 _ => return mkerr("InvalidListType"),
             };
@@ -404,7 +412,7 @@ fn type_one_layer(
         ExprKind::BinOp(BinOp::ListAppend, l, r) => {
             let l_ty = l.get_type()?;
             match &*l_ty.as_whnf() {
-                ValueKind::AppliedBuiltin(Builtin::List, _, _) => {}
+                ValueKind::AppliedBuiltin(Builtin::List, _, _, _) => {}
                 _ => return mkerr("BinOpTypeMismatch"),
             }
 
@@ -572,7 +580,7 @@ fn type_one_layer(
 
 /// Type-check an expression and return the expression alongside its type if type-checking
 /// succeeded, or an error if type-checking failed.
-fn type_with(
+pub(crate) fn type_with(
     env: &TyEnv,
     expr: &Expr<Normalized>,
 ) -> Result<TyExpr, TypeError> {
-- 
cgit v1.2.3


From 7683b0d762cf0df489ad4bc006e8db2358e81cf4 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 28 Jan 2020 21:50:04 +0000
Subject: Implement assert & merge and fix more bugs

---
 dhall/src/semantics/core/value.rs      |  47 ++++++--
 dhall/src/semantics/phase/normalize.rs |  20 +++-
 dhall/src/semantics/tck/typecheck.rs   | 208 +++++++++++++++++++--------------
 3 files changed, 171 insertions(+), 104 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 71c5c65..3dcbd38 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -56,10 +56,15 @@ pub(crate) enum Form {
 }
 
 #[derive(Debug, Clone)]
-pub(crate) struct Closure {
-    arg_ty: Value,
-    env: NzEnv,
-    body: TyExpr,
+pub(crate) enum Closure {
+    /// Normal closure
+    Closure {
+        arg_ty: Value,
+        env: NzEnv,
+        body: TyExpr,
+    },
+    /// Closure that ignores the argument passed
+    ConstantClosure { env: NzEnv, body: TyExpr },
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -696,21 +701,41 @@ impl<V> ValueKind<V> {
 
 impl Closure {
     pub fn new(arg_ty: Value, env: &NzEnv, body: TyExpr) -> Self {
-        Closure {
+        Closure::Closure {
             arg_ty,
             env: env.clone(),
             body,
         }
     }
+    pub fn new_constant(env: &NzEnv, body: TyExpr) -> Self {
+        Closure::ConstantClosure {
+            env: env.clone(),
+            body,
+        }
+    }
     pub fn apply(&self, val: Value) -> Value {
-        self.body.normalize_whnf(&self.env.insert_value(val))
+        match self {
+            Closure::Closure { env, body, .. } => {
+                body.normalize_whnf(&env.insert_value(val))
+            }
+            Closure::ConstantClosure { env, body, .. } => {
+                body.normalize_whnf(env)
+            }
+        }
     }
     pub fn apply_var(&self, var: NzVar) -> Value {
-        let val = Value::from_kind_and_type(
-            ValueKind::Var(AlphaVar::default(), var),
-            self.arg_ty.clone(),
-        );
-        self.apply(val)
+        match self {
+            Closure::Closure { arg_ty, .. } => {
+                let val = Value::from_kind_and_type(
+                    ValueKind::Var(AlphaVar::default(), var),
+                    arg_ty.clone(),
+                );
+                self.apply(val)
+            }
+            Closure::ConstantClosure { env, body, .. } => {
+                body.normalize_whnf(env)
+            }
+        }
     }
 }
 
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index a11cb75..532dae3 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -855,17 +855,30 @@ pub(crate) enum NzEnvItem {
 #[derive(Debug, Clone)]
 pub(crate) struct NzEnv {
     items: Vec<NzEnvItem>,
+    vars: QuoteEnv,
 }
 
 impl NzEnv {
     pub fn new() -> Self {
-        NzEnv { items: Vec::new() }
+        NzEnv {
+            items: Vec::new(),
+            vars: QuoteEnv::new(),
+        }
     }
     pub fn construct(items: Vec<NzEnvItem>) -> Self {
-        NzEnv { items }
+        let vars = QuoteEnv::construct(
+            items
+                .iter()
+                .filter(|i| match i {
+                    NzEnvItem::Kept(_) => true,
+                    NzEnvItem::Replaced(_) => false,
+                })
+                .count(),
+        );
+        NzEnv { items, vars }
     }
     pub fn as_quoteenv(&self) -> QuoteEnv {
-        QuoteEnv::construct(self.items.len())
+        self.vars
     }
     pub fn to_alpha_tyenv(&self) -> TyEnv {
         TyEnv::from_nzenv_alpha(self)
@@ -874,6 +887,7 @@ impl NzEnv {
     pub fn insert_type(&self, t: Value) -> Self {
         let mut env = self.clone();
         env.items.push(NzEnvItem::Kept(t));
+        env.vars = env.vars.insert();
         env
     }
     pub fn insert_value(&self, e: Value) -> Self {
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index e2619b5..1b8f261 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -7,7 +7,7 @@ use std::collections::HashMap;
 
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::context::TyCtx;
-use crate::semantics::nze::{NameEnv, QuoteEnv};
+use crate::semantics::nze::{NameEnv, NzVar, QuoteEnv};
 use crate::semantics::phase::normalize::{merge_maps, NzEnv};
 use crate::semantics::phase::typecheck::{
     builtin_to_value, const_to_value, type_of_builtin,
@@ -44,7 +44,7 @@ impl TyEnv {
         }
     }
     pub fn as_quoteenv(&self) -> QuoteEnv {
-        self.names.as_quoteenv()
+        self.items.as_quoteenv()
     }
     pub fn as_nzenv(&self) -> &NzEnv {
         &self.items
@@ -262,8 +262,7 @@ fn type_one_layer(
                                 ValueKind::PiClosure {
                                     binder: Binder::new(x.clone()),
                                     annot: ty.clone(),
-                                    closure: Closure::new(
-                                        ty.clone(),
+                                    closure: Closure::new_constant(
                                         env.as_nzenv(),
                                         scrut.clone(),
                                     ),
@@ -300,6 +299,15 @@ fn type_one_layer(
             }
             x_ty
         }
+        ExprKind::Assert(t) => {
+            let t = t.normalize_whnf(env.as_nzenv());
+            match &*t.as_whnf() {
+                ValueKind::Equivalence(x, y) if x == y => {}
+                ValueKind::Equivalence(..) => return mkerr("AssertMismatch"),
+                _ => return mkerr("AssertMustTakeEquivalence"),
+            }
+            t
+        }
         ExprKind::App(f, arg) => {
             let tf = f.get_type()?;
             let tf_borrow = tf.as_whnf();
@@ -458,88 +466,109 @@ fn type_one_layer(
 
             t
         }
-        // ExprKind::Merge(record, union, type_annot) => {
-        //     let record_type = record.get_type()?;
-        //     let record_borrow = record_type.as_whnf();
-        //     let handlers = match &*record_borrow {
-        //         ValueKind::RecordType(kts) => kts,
-        //         _ => return mkerr("Merge1ArgMustBeRecord"),
-        //     };
-
-        //     let union_type = union.get_type()?;
-        //     let union_borrow = union_type.as_whnf();
-        //     let variants = match &*union_borrow {
-        //         ValueKind::UnionType(kts) => Cow::Borrowed(kts),
-        //         ValueKind::AppliedBuiltin(
-        //             syntax::Builtin::Optional,
-        //             args,
-        //             _,
-        //         ) if args.len() == 1 => {
-        //             let ty = &args[0];
-        //             let mut kts = HashMap::new();
-        //             kts.insert("None".into(), None);
-        //             kts.insert("Some".into(), Some(ty.clone()));
-        //             Cow::Owned(kts)
-        //         }
-        //         _ => return mkerr("Merge2ArgMustBeUnionOrOptional"),
-        //     };
-
-        //     let mut inferred_type = None;
-        //     for (x, handler_type) in handlers {
-        //         let handler_return_type =
-        //             match variants.get(x) {
-        //                 // Union alternative with type
-        //                 Some(Some(variant_type)) => {
-        //                     let handler_type_borrow = handler_type.as_whnf();
-        //                     let (tx, tb) = match &*handler_type_borrow {
-        //                         ValueKind::Pi(_, tx, tb) => (tx, tb),
-        //                         _ => return mkerr("NotAFunction"),
-        //                     };
-
-        //                     if variant_type != tx {
-        //                         return mkerr("TypeMismatch");
-        //                     }
-
-        //                     // Extract `tb` from under the binder. Fails if the variable was used
-        //                     // in `tb`.
-        //                     match tb.over_binder() {
-        //                         Some(x) => x,
-        //                         None => return mkerr(
-        //                             "MergeHandlerReturnTypeMustNotBeDependent",
-        //                         ),
-        //                     }
-        //                 }
-        //                 // Union alternative without type
-        //                 Some(None) => handler_type.clone(),
-        //                 None => return mkerr("MergeHandlerMissingVariant"),
-        //             };
-        //         match &inferred_type {
-        //             None => inferred_type = Some(handler_return_type),
-        //             Some(t) => {
-        //                 if t != &handler_return_type {
-        //                     return mkerr("MergeHandlerTypeMismatch");
-        //                 }
-        //             }
-        //         }
-        //     }
-        //     for x in variants.keys() {
-        //         if !handlers.contains_key(x) {
-        //             return mkerr("MergeVariantMissingHandler");
-        //         }
-        //     }
-
-        //     match (inferred_type, type_annot.as_ref()) {
-        //         (Some(t1), Some(t2)) => {
-        //             if &t1 != t2 {
-        //                 return mkerr("MergeAnnotMismatch");
-        //             }
-        //             RetTypeOnly(t1)
-        //         }
-        //         (Some(t), None) => RetTypeOnly(t),
-        //         (None, Some(t)) => RetTypeOnly(t.clone()),
-        //         (None, None) => return mkerr("MergeEmptyNeedsAnnotation"),
-        //     }
-        // }
+        ExprKind::Merge(record, union, type_annot) => {
+            let record_type = record.get_type()?;
+            let record_borrow = record_type.as_whnf();
+            let handlers = match &*record_borrow {
+                ValueKind::RecordType(kts) => kts,
+                _ => return mkerr("Merge1ArgMustBeRecord"),
+            };
+
+            let union_type = union.get_type()?;
+            let union_borrow = union_type.as_whnf();
+            let variants = match &*union_borrow {
+                ValueKind::UnionType(kts) => Cow::Borrowed(kts),
+                ValueKind::AppliedBuiltin(
+                    syntax::Builtin::Optional,
+                    args,
+                    _,
+                    _,
+                ) if args.len() == 1 => {
+                    let ty = &args[0];
+                    let mut kts = HashMap::new();
+                    kts.insert("None".into(), None);
+                    kts.insert("Some".into(), Some(ty.clone()));
+                    Cow::Owned(kts)
+                }
+                _ => return mkerr("Merge2ArgMustBeUnionOrOptional"),
+            };
+
+            let mut inferred_type = None;
+            for (x, handler_type) in handlers {
+                let handler_return_type = match variants.get(x) {
+                    // Union alternative with type
+                    Some(Some(variant_type)) => {
+                        let handler_type_borrow = handler_type.as_whnf();
+                        match &*handler_type_borrow {
+                            ValueKind::Pi(_, tx, tb) => {
+                                if variant_type != tx {
+                                    return mkerr("MergeHandlerTypeMismatch");
+                                }
+
+                                // Extract `tb` from under the binder. Fails if the variable was used
+                                // in `tb`.
+                                match tb.over_binder() {
+                                    Some(x) => x,
+                                    None => return mkerr(
+                                        "MergeHandlerReturnTypeMustNotBeDependent",
+                                    ),
+                                }
+                            }
+                            ValueKind::PiClosure { closure, annot, .. } => {
+                                if variant_type != annot {
+                                    // return mkerr("MergeHandlerTypeMismatch");
+                                    return mkerr(format!(
+                                        "MergeHandlerTypeMismatch: {:#?} != {:#?}",
+                                        variant_type,
+                                        annot
+                                    ));
+                                }
+
+                                let v = NzVar::fresh();
+                                // TODO: handle case where variable is used in closure
+                                closure.apply_var(v)
+                            }
+                            _ => return mkerr("NotAFunction"),
+                        }
+                    }
+                    // Union alternative without type
+                    Some(None) => handler_type.clone(),
+                    None => return mkerr("MergeHandlerMissingVariant"),
+                };
+                match &inferred_type {
+                    None => inferred_type = Some(handler_return_type),
+                    Some(t) => {
+                        if t != &handler_return_type {
+                            // return mkerr("MergeHandlerTypeMismatch");
+                            return mkerr(format!(
+                                "MergeHandlerTypeMismatch: {:#?} != {:#?}",
+                                t, handler_return_type,
+                            ));
+                        }
+                    }
+                }
+            }
+            for x in variants.keys() {
+                if !handlers.contains_key(x) {
+                    return mkerr("MergeVariantMissingHandler");
+                }
+            }
+
+            let type_annot = type_annot
+                .as_ref()
+                .map(|t| t.normalize_whnf(env.as_nzenv()));
+            match (inferred_type, type_annot) {
+                (Some(t1), Some(t2)) => {
+                    if t1 != t2 {
+                        return mkerr("MergeAnnotMismatch");
+                    }
+                    t1
+                }
+                (Some(t), None) => t,
+                (None, Some(t)) => t,
+                (None, None) => return mkerr("MergeEmptyNeedsAnnotation"),
+            }
+        }
         ExprKind::ToMap(_, _) => unimplemented!("toMap"),
         ExprKind::Projection(record, labels) => {
             let record_type = record.get_type()?;
@@ -574,7 +603,6 @@ fn type_one_layer(
             unimplemented!("selection by expression")
         }
         ExprKind::Completion(_, _) => unimplemented!("record completion"),
-        _ => Value::from_const(Const::Type), // TODO
     })
 }
 
@@ -592,14 +620,14 @@ pub(crate) fn type_with(
         ExprKind::Lam(binder, annot, body) => {
             let annot = type_with(env, annot)?;
             let annot_nf = annot.normalize_whnf(env.as_nzenv());
-            let body =
-                type_with(&env.insert_type(&binder, annot_nf.clone()), body)?;
+            let body_env = env.insert_type(&binder, annot_nf.clone());
+            let body = type_with(&body_env, body)?;
             let body_ty = body.get_type()?;
             let ty = TyExpr::new(
                 TyExprKind::Expr(ExprKind::Pi(
                     binder.clone(),
                     annot.clone(),
-                    body_ty.to_tyexpr(env.as_quoteenv().insert()),
+                    body_ty.to_tyexpr(body_env.as_quoteenv()),
                 )),
                 Some(type_of_function(annot.get_type()?, body_ty.get_type()?)?),
                 Span::Artificial,
-- 
cgit v1.2.3


From f31ccaa40df77b1ca8b37db46a819460c831006e Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 29 Jan 2020 18:17:12 +0000
Subject: Fix more bugs

---
 dhall/build.rs                         |  4 ++
 dhall/src/semantics/phase/normalize.rs | 32 ++--------------
 dhall/src/semantics/tck/typecheck.rs   | 69 ++++++++++++++++++----------------
 dhall/src/tests.rs                     | 18 +++++++--
 4 files changed, 58 insertions(+), 65 deletions(-)

(limited to 'dhall')

diff --git a/dhall/build.rs b/dhall/build.rs
index c95a26d..cc94f5e 100644
--- a/dhall/build.rs
+++ b/dhall/build.rs
@@ -339,6 +339,8 @@ fn generate_tests() -> std::io::Result<()> {
                     || path == "unit/CompletionWithWrongDefaultType"
                     || path == "unit/CompletionWithWrongFieldName"
                     || path == "unit/CompletionWithWrongOverridenType"
+                    // TODO: enable free variable checking
+                    || path == "unit/MergeHandlerFreeVar"
             }),
             input_type: FileType::Text,
             output_type: None,
@@ -367,6 +369,8 @@ fn generate_tests() -> std::io::Result<()> {
                     || path == "unit/CompletionWithWrongDefaultType"
                     || path == "unit/CompletionWithWrongFieldName"
                     || path == "unit/CompletionWithWrongOverridenType"
+                    // TODO: enable free variable checking
+                    || path == "unit/MergeHandlerFreeVar"
             }),
             input_type: FileType::Text,
             output_type: None,
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index 532dae3..f4e4099 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -2,7 +2,7 @@
 use std::collections::HashMap;
 use std::convert::TryInto;
 
-use crate::semantics::nze::{NzVar, QuoteEnv};
+use crate::semantics::nze::NzVar;
 use crate::semantics::phase::typecheck::{
     builtin_to_value_env, const_to_value, rc,
 };
@@ -855,30 +855,14 @@ pub(crate) enum NzEnvItem {
 #[derive(Debug, Clone)]
 pub(crate) struct NzEnv {
     items: Vec<NzEnvItem>,
-    vars: QuoteEnv,
 }
 
 impl NzEnv {
     pub fn new() -> Self {
-        NzEnv {
-            items: Vec::new(),
-            vars: QuoteEnv::new(),
-        }
+        NzEnv { items: Vec::new() }
     }
     pub fn construct(items: Vec<NzEnvItem>) -> Self {
-        let vars = QuoteEnv::construct(
-            items
-                .iter()
-                .filter(|i| match i {
-                    NzEnvItem::Kept(_) => true,
-                    NzEnvItem::Replaced(_) => false,
-                })
-                .count(),
-        );
-        NzEnv { items, vars }
-    }
-    pub fn as_quoteenv(&self) -> QuoteEnv {
-        self.vars
+        NzEnv { items }
     }
     pub fn to_alpha_tyenv(&self) -> TyEnv {
         TyEnv::from_nzenv_alpha(self)
@@ -887,7 +871,6 @@ impl NzEnv {
     pub fn insert_type(&self, t: Value) -> Self {
         let mut env = self.clone();
         env.items.push(NzEnvItem::Kept(t));
-        env.vars = env.vars.insert();
         env
     }
     pub fn insert_value(&self, e: Value) -> Self {
@@ -897,16 +880,9 @@ impl NzEnv {
     }
     pub fn lookup_val(&self, var: &AlphaVar) -> Value {
         let idx = self.items.len() - 1 - var.idx();
-        let var_idx = self.items[..idx]
-            .iter()
-            .filter(|i| match i {
-                NzEnvItem::Kept(_) => true,
-                NzEnvItem::Replaced(_) => false,
-            })
-            .count();
         match &self.items[idx] {
             NzEnvItem::Kept(ty) => Value::from_kind_and_type_whnf(
-                ValueKind::Var(var.clone(), NzVar::new(var_idx)),
+                ValueKind::Var(var.clone(), NzVar::new(idx)),
                 ty.clone(),
             ),
             NzEnvItem::Replaced(x) => x.clone(),
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index 1b8f261..a83f175 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -44,7 +44,7 @@ impl TyEnv {
         }
     }
     pub fn as_quoteenv(&self) -> QuoteEnv {
-        self.items.as_quoteenv()
+        self.names.as_quoteenv()
     }
     pub fn as_nzenv(&self) -> &NzEnv {
         &self.items
@@ -70,9 +70,6 @@ impl TyEnv {
         let ty = self.items.lookup_val(&var).get_type().unwrap();
         Some((TyExprKind::Var(var), ty))
     }
-    pub fn size(&self) -> usize {
-        self.names.size()
-    }
 }
 
 fn type_of_recordtype<'a>(
@@ -312,33 +309,24 @@ fn type_one_layer(
             let tf = f.get_type()?;
             let tf_borrow = tf.as_whnf();
             match &*tf_borrow {
-                // ValueKind::PiClosure { annot, closure, .. } => (annot, closure),
-                ValueKind::PiClosure {
-                    annot: _expected_arg_ty,
-                    closure: ty_closure,
-                    ..
-                } => {
-                    // if arg.get_type()? != *expected_arg_ty {
-                    //     return mkerr(format!(
-                    //         "function annot mismatch: {:?}, {:?}",
-                    //         arg.get_type()?,
-                    //         expected_arg_ty
-                    //     ));
-                    // }
+                ValueKind::PiClosure { annot, closure, .. } => {
+                    if arg.get_type()? != *annot {
+                        // return mkerr(format!("function annot mismatch"));
+                        return mkerr(format!(
+                            "function annot mismatch: ({} : {}) : {}",
+                            arg.to_expr_tyenv(env),
+                            arg.get_type()?
+                                .to_tyexpr(env.as_quoteenv())
+                                .to_expr_tyenv(env),
+                            annot
+                                .to_tyexpr(env.as_quoteenv())
+                                .to_expr_tyenv(env),
+                        ));
+                    }
 
                     let arg_nf = arg.normalize_whnf(env.as_nzenv());
-                    ty_closure.apply(arg_nf)
+                    closure.apply(arg_nf)
                 }
-                // ValueKind::Pi(_, _expected_arg_ty, body) => {
-                //     // if arg.get_type()? != *tx {
-                //     //     return mkerr("TypeMismatch");
-                //     // }
-
-                //     let arg_nf = arg.normalize_whnf(env.as_nzenv());
-                //     let ret = body.subst_shift(&AlphaVar::default(), &arg_nf);
-                //     ret.normalize_nf();
-                //     ret
-                // }
                 _ => return mkerr(format!("apply to not Pi: {:?}", tf_borrow)),
             }
         }
@@ -404,14 +392,29 @@ fn type_one_layer(
         ExprKind::BinOp(BinOp::RecursiveRecordTypeMerge, x, y) => {
             let x_val = x.normalize_whnf(env.as_nzenv());
             let y_val = y.normalize_whnf(env.as_nzenv());
-            match &*x_val.as_whnf() {
-                ValueKind::RecordType(_) => {}
+            let x_val_borrow = x_val.as_whnf();
+            let y_val_borrow = y_val.as_whnf();
+            let kts_x = match &*x_val_borrow {
+                ValueKind::RecordType(kts) => kts,
                 _ => return mkerr("RecordTypeMergeRequiresRecordType"),
-            }
-            match &*y_val.as_whnf() {
-                ValueKind::RecordType(_) => {}
+            };
+            let kts_y = match &*y_val_borrow {
+                ValueKind::RecordType(kts) => kts,
                 _ => return mkerr("RecordTypeMergeRequiresRecordType"),
+            };
+            for (k, tx) in kts_x {
+                if let Some(ty) = kts_y.get(k) {
+                    type_one_layer(
+                        env,
+                        &ExprKind::BinOp(
+                            BinOp::RecursiveRecordTypeMerge,
+                            tx.to_tyexpr(env.as_quoteenv()),
+                            ty.to_tyexpr(env.as_quoteenv()),
+                        ),
+                    )?;
+                }
             }
+
             // A RecordType's type is always a const
             let xk = x.get_type()?.as_const().unwrap();
             let yk = y.get_type()?.as_const().unwrap();
diff --git a/dhall/src/tests.rs b/dhall/src/tests.rs
index 971c48d..1c687f6 100644
--- a/dhall/src/tests.rs
+++ b/dhall/src/tests.rs
@@ -193,13 +193,23 @@ pub fn run_test(test: Test<'_>) -> Result<()> {
             // assert_eq_pretty!(ty, expected);
         }
         TypeInferenceFailure(file_path) => {
-            let mut res =
-                parse_file_str(&file_path)?.skip_resolve()?.typecheck();
+            // let mut res =
+            //     parse_file_str(&file_path)?.skip_resolve()?.typecheck();
+            // if let Ok(e) = &res {
+            //     // If e did typecheck, check that get_type fails
+            //     res = e.get_type();
+            // }
+            // res.unwrap_err();
+
+            let res = crate::semantics::tck::typecheck::typecheck(
+                &parse_file_str(&file_path)?.skip_resolve()?.to_expr(),
+            );
             if let Ok(e) = &res {
                 // If e did typecheck, check that get_type fails
-                res = e.get_type();
+                e.get_type().unwrap_err();
+            } else {
+                res.unwrap_err();
             }
-            res.unwrap_err();
         }
         // Checks the output of the type error against a text file. If the text file doesn't exist,
         // we instead write to it the output we got. This makes it easy to update those files: just
-- 
cgit v1.2.3


From f88880004c7dcf5e67c4d5e2330e6e879523f27b Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 29 Jan 2020 18:30:12 +0000
Subject: Use Normalized in serde_dhall

---
 dhall/src/semantics/phase/mod.rs | 126 +++++++++++++++++++++++----------------
 1 file changed, 74 insertions(+), 52 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/phase/mod.rs b/dhall/src/semantics/phase/mod.rs
index 67cdc91..68c32b2 100644
--- a/dhall/src/semantics/phase/mod.rs
+++ b/dhall/src/semantics/phase/mod.rs
@@ -35,7 +35,7 @@ pub struct Typed(Value);
 ///
 /// Invariant: the contained Typed expression must be in normal form,
 #[derive(Debug, Clone)]
-pub struct Normalized(Typed);
+pub struct Normalized(Value);
 
 /// Controls conversion from `Value` to `Expr`
 #[derive(Copy, Clone)]
@@ -81,9 +81,8 @@ impl Resolved {
     pub fn typecheck(self) -> Result<Typed, TypeError> {
         Ok(typecheck::typecheck(self.0)?.into_typed())
     }
-    pub fn typecheck_with(self, ty: &Typed) -> Result<Typed, TypeError> {
-        Ok(typecheck::typecheck_with(self.0, ty.normalize_to_expr())?
-            .into_typed())
+    pub fn typecheck_with(self, ty: &Normalized) -> Result<Typed, TypeError> {
+        Ok(typecheck::typecheck_with(self.0, ty.to_expr())?.into_typed())
     }
     /// Converts a value back to the corresponding AST expression.
     pub fn to_expr(&self) -> ResolvedExpr {
@@ -92,39 +91,30 @@ impl Resolved {
     pub fn tck_and_normalize_new_flow(&self) -> Result<Normalized, TypeError> {
         let val = crate::semantics::tck::typecheck::typecheck(&self.0)?
             .normalize_whnf_noenv();
-        Ok(Normalized(Typed(val)))
+        Ok(Normalized(val))
     }
 }
 
 impl Typed {
     /// Reduce an expression to its normal form, performing beta reduction
     pub fn normalize(mut self) -> Normalized {
-        self.normalize_mut();
-        Normalized(self)
+        self.0.normalize_mut();
+        Normalized(self.0)
     }
 
-    pub(crate) fn from_const(c: Const) -> Self {
-        Typed(Value::from_const(c))
-    }
-    pub(crate) fn from_kind_and_type(v: ValueKind<Value>, t: Typed) -> Self {
-        Typed(Value::from_kind_and_type(v, t.into_value()))
-    }
     pub(crate) fn from_value(th: Value) -> Self {
         Typed(th)
     }
-    pub(crate) fn const_type() -> Self {
-        Typed::from_const(Const::Type)
-    }
 
     /// Converts a value back to the corresponding AST expression.
-    pub fn to_expr(&self) -> ResolvedExpr {
+    pub(crate) fn to_expr(&self) -> ResolvedExpr {
         self.0.to_expr(ToExprOptions {
             alpha: false,
             normalize: false,
         })
     }
     /// Converts a value back to the corresponding AST expression, beta-normalizing in the process.
-    pub fn normalize_to_expr(&self) -> NormalizedExpr {
+    pub(crate) fn normalize_to_expr(&self) -> NormalizedExpr {
         self.0.to_expr(ToExprOptions {
             alpha: false,
             normalize: true,
@@ -138,6 +128,34 @@ impl Typed {
             normalize: true,
         })
     }
+    pub(crate) fn into_value(self) -> Value {
+        self.0
+    }
+
+    pub(crate) fn get_type(&self) -> Result<Typed, TypeError> {
+        Ok(self.0.get_type()?.into_typed())
+    }
+}
+
+impl Normalized {
+    pub fn encode(&self) -> Result<Vec<u8>, EncodeError> {
+        binary::encode(&self.to_expr())
+    }
+
+    pub fn to_expr(&self) -> NormalizedExpr {
+        // TODO: do it directly
+        self.to_typed().normalize_to_expr()
+    }
+    pub(crate) fn to_expr_alpha(&self) -> NormalizedExpr {
+        // TODO: do it directly
+        self.to_typed().normalize_to_expr_alpha()
+    }
+    pub(crate) fn to_typed(&self) -> Typed {
+        Typed(self.0.clone())
+    }
+    pub(crate) fn into_typed(self) -> Typed {
+        Typed(self.0)
+    }
     pub(crate) fn to_value(&self) -> Value {
         self.0.clone()
     }
@@ -145,64 +163,58 @@ impl Typed {
         self.0
     }
 
-    pub(crate) fn normalize_mut(&mut self) {
-        self.0.normalize_mut()
+    pub(crate) fn from_const(c: Const) -> Self {
+        Normalized(Value::from_const(c))
     }
-
-    pub(crate) fn get_type(&self) -> Result<Typed, TypeError> {
-        Ok(self.0.get_type()?.into_typed())
+    pub(crate) fn from_kind_and_type(
+        v: ValueKind<Value>,
+        t: Normalized,
+    ) -> Self {
+        Normalized(Value::from_kind_and_type(v, t.into_value()))
+    }
+    pub(crate) fn from_value(th: Value) -> Self {
+        Normalized(th)
+    }
+    pub(crate) fn const_type() -> Self {
+        Normalized::from_const(Const::Type)
     }
 
     pub fn make_builtin_type(b: Builtin) -> Self {
-        Typed::from_value(Value::from_builtin(b))
+        Normalized::from_value(Value::from_builtin(b))
     }
-    pub fn make_optional_type(t: Typed) -> Self {
-        Typed::from_value(
+    pub fn make_optional_type(t: Normalized) -> Self {
+        Normalized::from_value(
             Value::from_builtin(Builtin::Optional).app(t.to_value()),
         )
     }
-    pub fn make_list_type(t: Typed) -> Self {
-        Typed::from_value(Value::from_builtin(Builtin::List).app(t.to_value()))
+    pub fn make_list_type(t: Normalized) -> Self {
+        Normalized::from_value(
+            Value::from_builtin(Builtin::List).app(t.to_value()),
+        )
     }
     pub fn make_record_type(
-        kts: impl Iterator<Item = (String, Typed)>,
+        kts: impl Iterator<Item = (String, Normalized)>,
     ) -> Self {
-        Typed::from_kind_and_type(
+        Normalized::from_kind_and_type(
             ValueKind::RecordType(
                 kts.map(|(k, t)| (k.into(), t.into_value())).collect(),
             ),
-            Typed::const_type(),
+            Normalized::const_type(),
         )
     }
     pub fn make_union_type(
-        kts: impl Iterator<Item = (String, Option<Typed>)>,
+        kts: impl Iterator<Item = (String, Option<Normalized>)>,
     ) -> Self {
-        Typed::from_kind_and_type(
+        Normalized::from_kind_and_type(
             ValueKind::UnionType(
                 kts.map(|(k, t)| (k.into(), t.map(|t| t.into_value())))
                     .collect(),
             ),
-            Typed::const_type(),
+            Normalized::const_type(),
         )
     }
 }
 
-impl Normalized {
-    pub fn encode(&self) -> Result<Vec<u8>, EncodeError> {
-        binary::encode(&self.to_expr())
-    }
-
-    pub(crate) fn to_expr(&self) -> NormalizedExpr {
-        self.0.normalize_to_expr()
-    }
-    pub(crate) fn to_expr_alpha(&self) -> NormalizedExpr {
-        self.0.normalize_to_expr_alpha()
-    }
-    pub(crate) fn into_typed(self) -> Typed {
-        self.0
-    }
-}
-
 macro_rules! derive_traits_for_wrapper_struct {
     ($ty:ident) => {
         impl std::cmp::PartialEq for $ty {
@@ -226,7 +238,6 @@ macro_rules! derive_traits_for_wrapper_struct {
 
 derive_traits_for_wrapper_struct!(Parsed);
 derive_traits_for_wrapper_struct!(Resolved);
-derive_traits_for_wrapper_struct!(Normalized);
 
 impl std::hash::Hash for Normalized {
     fn hash<H>(&self, state: &mut H)
@@ -245,9 +256,20 @@ impl PartialEq for Typed {
         self.0 == other.0
     }
 }
-
 impl Display for Typed {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
         self.to_expr().fmt(f)
     }
 }
+
+impl Eq for Normalized {}
+impl PartialEq for Normalized {
+    fn eq(&self, other: &Self) -> bool {
+        self.0 == other.0
+    }
+}
+impl Display for Normalized {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        self.to_expr().fmt(f)
+    }
+}
-- 
cgit v1.2.3


From 1e466a20533d936f44430b1bc18508cd00e5ccd2 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 29 Jan 2020 18:48:19 +0000
Subject: Use TyExpr in Typed

---
 dhall/src/semantics/core/value.rs                  |  7 +-
 dhall/src/semantics/phase/mod.rs                   | 69 +++++++-----------
 dhall/src/semantics/phase/typecheck.rs             |  2 +-
 dhall/src/semantics/tck/typecheck.rs               |  9 ++-
 dhall/src/tests.rs                                 | 85 ++++------------------
 dhall/tests/type-errors/hurkensParadox.txt         |  2 +-
 dhall/tests/type-errors/mixedUnions.txt            |  2 +-
 .../unit/AnnotationRecordWrongFieldName.txt        |  2 +-
 .../unit/AnnotationRecordWrongFieldType.txt        |  2 +-
 dhall/tests/type-errors/unit/AssertAlphaTrap.txt   |  7 +-
 .../tests/type-errors/unit/EquivalenceNotTerms.txt |  2 +-
 .../unit/FunctionApplicationArgumentNotMatch.txt   |  2 +-
 .../unit/FunctionApplicationIsNotFunction.txt      |  2 +-
 .../unit/FunctionArgumentTypeNotAType.txt          |  7 +-
 .../unit/FunctionTypeArgumentTypeNotAType.txt      |  7 +-
 .../type-errors/unit/LetWithWrongAnnotation.txt    |  2 +-
 .../type-errors/unit/ListLiteralEmptyNotType.txt   |  2 +-
 .../tests/type-errors/unit/MergeHandlerFreeVar.txt |  1 -
 .../unit/MergeHandlerNotMatchAlternativeType.txt   | 22 +++++-
 .../unit/MergeHandlersWithDifferentType.txt        | 66 ++++++++++++++++-
 .../type-errors/unit/NaturalSubtractNotNatural.txt |  2 +-
 .../unit/OptionalDeprecatedSyntaxPresent.txt       |  2 +-
 .../type-errors/unit/RecordTypeValueMember.txt     |  2 +-
 .../tests/type-errors/unit/TypeAnnotationWrong.txt |  2 +-
 .../unit/UnionDeprecatedConstructorsKeyword.txt    |  7 +-
 .../tests/type-errors/unit/UnionTypeMixedKinds.txt |  2 +-
 .../type-errors/unit/UnionTypeMixedKinds2.txt      |  2 +-
 .../type-errors/unit/UnionTypeMixedKinds3.txt      |  2 +-
 dhall/tests/type-errors/unit/UnionTypeNotType.txt  |  2 +-
 dhall/tests/type-errors/unit/VariableFree.txt      |  7 +-
 30 files changed, 158 insertions(+), 172 deletions(-)
 delete mode 100644 dhall/tests/type-errors/unit/MergeHandlerFreeVar.txt

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 3dcbd38..aa819d2 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -9,9 +9,7 @@ use crate::semantics::phase::normalize::{apply_any, normalize_whnf, NzEnv};
 use crate::semantics::phase::typecheck::{
     builtin_to_value, builtin_to_value_env, const_to_value,
 };
-use crate::semantics::phase::{
-    Normalized, NormalizedExpr, ToExprOptions, Typed,
-};
+use crate::semantics::phase::{Normalized, NormalizedExpr, ToExprOptions};
 use crate::semantics::{TyExpr, TyExprKind};
 use crate::syntax::{
     BinOp, Builtin, Const, ExprKind, Integer, InterpolatedTextContents, Label,
@@ -207,9 +205,6 @@ impl Value {
         self.check_type(ty);
         self.to_whnf_ignore_type()
     }
-    pub(crate) fn into_typed(self) -> Typed {
-        Typed::from_value(self)
-    }
 
     /// Mutates the contents. If no one else shares this, this avoids a RefCell lock.
     fn mutate_internal(&mut self, f: impl FnOnce(&mut ValueInternal)) {
diff --git a/dhall/src/semantics/phase/mod.rs b/dhall/src/semantics/phase/mod.rs
index 68c32b2..0f8194c 100644
--- a/dhall/src/semantics/phase/mod.rs
+++ b/dhall/src/semantics/phase/mod.rs
@@ -4,6 +4,7 @@ use std::path::Path;
 use crate::error::{EncodeError, Error, ImportError, TypeError};
 use crate::semantics::core::value::Value;
 use crate::semantics::core::value::ValueKind;
+use crate::semantics::tck::tyexpr::TyExpr;
 use crate::syntax::binary;
 use crate::syntax::{Builtin, Const, Expr};
 use resolve::ImportRoot;
@@ -29,7 +30,7 @@ pub struct Resolved(ResolvedExpr);
 
 /// A typed expression
 #[derive(Debug, Clone)]
-pub struct Typed(Value);
+pub struct Typed(TyExpr);
 
 /// A normalized expression.
 ///
@@ -78,11 +79,14 @@ impl Parsed {
 }
 
 impl Resolved {
-    pub fn typecheck(self) -> Result<Typed, TypeError> {
-        Ok(typecheck::typecheck(self.0)?.into_typed())
+    pub fn typecheck(&self) -> Result<Typed, TypeError> {
+        Ok(Typed(crate::semantics::tck::typecheck::typecheck(&self.0)?))
     }
     pub fn typecheck_with(self, ty: &Normalized) -> Result<Typed, TypeError> {
-        Ok(typecheck::typecheck_with(self.0, ty.to_expr())?.into_typed())
+        Ok(Typed(crate::semantics::tck::typecheck::typecheck_with(
+            &self.0,
+            ty.to_expr(),
+        )?))
     }
     /// Converts a value back to the corresponding AST expression.
     pub fn to_expr(&self) -> ResolvedExpr {
@@ -97,43 +101,22 @@ impl Resolved {
 
 impl Typed {
     /// Reduce an expression to its normal form, performing beta reduction
-    pub fn normalize(mut self) -> Normalized {
-        self.0.normalize_mut();
-        Normalized(self.0)
-    }
-
-    pub(crate) fn from_value(th: Value) -> Self {
-        Typed(th)
+    pub fn normalize(&self) -> Normalized {
+        let mut val = self.0.normalize_whnf_noenv();
+        val.normalize_mut();
+        Normalized(val)
     }
 
     /// Converts a value back to the corresponding AST expression.
-    pub(crate) fn to_expr(&self) -> ResolvedExpr {
+    fn to_expr(&self) -> ResolvedExpr {
         self.0.to_expr(ToExprOptions {
             alpha: false,
             normalize: false,
         })
     }
-    /// Converts a value back to the corresponding AST expression, beta-normalizing in the process.
-    pub(crate) fn normalize_to_expr(&self) -> NormalizedExpr {
-        self.0.to_expr(ToExprOptions {
-            alpha: false,
-            normalize: true,
-        })
-    }
-    /// Converts a value back to the corresponding AST expression, (alpha,beta)-normalizing in the
-    /// process.
-    pub(crate) fn normalize_to_expr_alpha(&self) -> NormalizedExpr {
-        self.0.to_expr(ToExprOptions {
-            alpha: true,
-            normalize: true,
-        })
-    }
-    pub(crate) fn into_value(self) -> Value {
-        self.0
-    }
 
-    pub(crate) fn get_type(&self) -> Result<Typed, TypeError> {
-        Ok(self.0.get_type()?.into_typed())
+    pub(crate) fn get_type(&self) -> Result<Normalized, TypeError> {
+        Ok(Normalized(self.0.get_type()?))
     }
 }
 
@@ -142,19 +125,19 @@ impl Normalized {
         binary::encode(&self.to_expr())
     }
 
+    /// Converts a value back to the corresponding AST expression.
     pub fn to_expr(&self) -> NormalizedExpr {
-        // TODO: do it directly
-        self.to_typed().normalize_to_expr()
+        self.0.to_expr(ToExprOptions {
+            alpha: false,
+            normalize: false,
+        })
     }
+    /// Converts a value back to the corresponding AST expression, alpha-normalizing in the process.
     pub(crate) fn to_expr_alpha(&self) -> NormalizedExpr {
-        // TODO: do it directly
-        self.to_typed().normalize_to_expr_alpha()
-    }
-    pub(crate) fn to_typed(&self) -> Typed {
-        Typed(self.0.clone())
-    }
-    pub(crate) fn into_typed(self) -> Typed {
-        Typed(self.0)
+        self.0.to_expr(ToExprOptions {
+            alpha: true,
+            normalize: false,
+        })
     }
     pub(crate) fn to_value(&self) -> Value {
         self.0.clone()
@@ -253,7 +236,7 @@ impl std::hash::Hash for Normalized {
 impl Eq for Typed {}
 impl PartialEq for Typed {
     fn eq(&self, other: &Self) -> bool {
-        self.0 == other.0
+        self.normalize() == other.normalize()
     }
 }
 impl Display for Typed {
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index f559323..6de65e8 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -336,7 +336,7 @@ fn type_with(ctx: &TyCtx, e: Expr<Normalized>) -> Result<Value, TypeError> {
             // ))
             Ok(e)
         }
-        Embed(p) => Ok(p.clone().into_typed().into_value()),
+        Embed(p) => Ok(p.clone().into_value()),
         Var(var) => match ctx.lookup(&var) {
             Some(typed) => Ok(typed.clone()),
             None => Err(TypeError::new(TypeMessage::UnboundVariable(span))),
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index a83f175..5880d92 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -677,7 +677,7 @@ pub(crate) fn type_with(
             (TyExprKind::Expr(ExprKind::Const(Const::Sort)), None)
         }
         ExprKind::Embed(p) => {
-            return Ok(p.clone().into_typed().into_value().to_tyexpr_noenv())
+            return Ok(p.clone().into_value().to_tyexpr_noenv())
         }
         ekind => {
             let ekind = ekind.traverse_ref(|e| type_with(env, e))?;
@@ -692,3 +692,10 @@ pub(crate) fn type_with(
 pub(crate) fn typecheck(e: &Expr<Normalized>) -> Result<TyExpr, TypeError> {
     type_with(&TyEnv::new(), e)
 }
+
+pub(crate) fn typecheck_with(
+    expr: &Expr<Normalized>,
+    ty: Expr<Normalized>,
+) -> Result<TyExpr, TypeError> {
+    typecheck(&expr.rewrap(ExprKind::Annot(expr.clone(), ty)))
+}
diff --git a/dhall/src/tests.rs b/dhall/src/tests.rs
index 1c687f6..08feadf 100644
--- a/dhall/src/tests.rs
+++ b/dhall/src/tests.rs
@@ -158,65 +158,24 @@ pub fn run_test(test: Test<'_>) -> Result<()> {
             parse_file_str(&file_path)?.resolve().unwrap_err();
         }
         TypeInferenceSuccess(expr_file_path, expected_file_path) => {
-            // let expr =
-            //     parse_file_str(&expr_file_path)?.resolve()?.typecheck()?;
-            // let ty = expr.get_type()?.to_expr();
-            // let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
-            // let tyexpr = crate::semantics::nze::nzexpr::typecheck(expr)?;
-            // let ty = tyexpr.get_type()?.to_expr();
-            //
-            let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
-            let ty = crate::semantics::tck::typecheck::typecheck(&expr)?
-                .get_type()?
-                .to_expr(crate::semantics::phase::ToExprOptions {
-                    alpha: false,
-                    normalize: true,
-                });
+            let expr =
+                parse_file_str(&expr_file_path)?.resolve()?.typecheck()?;
+            let ty = expr.get_type()?.to_expr();
             let expected = parse_file_str(&expected_file_path)?.to_expr();
             assert_eq_display!(ty, expected);
-            //
-            // let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
-            // let ty = crate::semantics::tck::typecheck::typecheck(&expr)?
-            //     .get_type()?;
-            // let expected = parse_file_str(&expected_file_path)?.to_expr();
-            // let expected = crate::semantics::tck::typecheck::typecheck(&expected)?
-            //     .normalize_whnf_noenv();
-            // // if ty != expected {
-            // //     assert_eq_display!(ty.to_expr(crate::semantics::phase::ToExprOptions {
-            // //         alpha: false,
-            // //         normalize: true,
-            // //     }), expected.to_expr(crate::semantics::phase::ToExprOptions {
-            // //         alpha: false,
-            // //         normalize: true,
-            // //     }))
-            // // }
-            // assert_eq_pretty!(ty, expected);
         }
         TypeInferenceFailure(file_path) => {
-            // let mut res =
-            //     parse_file_str(&file_path)?.skip_resolve()?.typecheck();
-            // if let Ok(e) = &res {
-            //     // If e did typecheck, check that get_type fails
-            //     res = e.get_type();
-            // }
-            // res.unwrap_err();
-
-            let res = crate::semantics::tck::typecheck::typecheck(
-                &parse_file_str(&file_path)?.skip_resolve()?.to_expr(),
-            );
+            let res = parse_file_str(&file_path)?.skip_resolve()?.typecheck();
             if let Ok(e) = &res {
                 // If e did typecheck, check that get_type fails
                 e.get_type().unwrap_err();
-            } else {
-                res.unwrap_err();
             }
         }
         // Checks the output of the type error against a text file. If the text file doesn't exist,
         // we instead write to it the output we got. This makes it easy to update those files: just
         // `rm -r dhall/tests/type-errors` and run the tests again.
         TypeError(file_path) => {
-            let mut res =
-                parse_file_str(&file_path)?.skip_resolve()?.typecheck();
+            let res = parse_file_str(&file_path)?.skip_resolve()?.typecheck();
             let file_path = PathBuf::from(file_path);
             let error_file_path = file_path
                 .strip_prefix("../dhall-lang/tests/type-inference/failure/")
@@ -224,11 +183,13 @@ pub fn run_test(test: Test<'_>) -> Result<()> {
             let error_file_path =
                 PathBuf::from("tests/type-errors/").join(error_file_path);
             let error_file_path = error_file_path.with_extension("txt");
-            if let Ok(e) = &res {
-                // If e did typecheck, check that get_type fails
-                res = e.get_type();
-            }
-            let err: Error = res.unwrap_err().into();
+            let err: Error = match res {
+                Ok(e) => {
+                    // If e did typecheck, check that get_type fails
+                    e.get_type().unwrap_err().into()
+                }
+                Err(e) => e.into(),
+            };
 
             if error_file_path.is_file() {
                 let expected_msg = std::fs::read_to_string(error_file_path)?;
@@ -241,28 +202,10 @@ pub fn run_test(test: Test<'_>) -> Result<()> {
             }
         }
         Normalization(expr_file_path, expected_file_path) => {
-            // let expr = parse_file_str(&expr_file_path)?
-            //     .resolve()?
-            //     .typecheck()?
-            //     .normalize()
-            //     .to_expr();
-            // let expr = parse_file_str(&expr_file_path)?.resolve()?.to_expr();
-            // let expr = crate::semantics::nze::nzexpr::typecheck(expr)?
-            //     .normalize()
-            //     .to_expr();
-            // let expr = parse_file_str(&expr_file_path)?
-            //     .resolve()?
-            //     .typecheck()?
-            //     .to_value()
-            //     .to_tyexpr_noenv()
-            //     .normalize_whnf_noenv()
-            //     .to_expr(crate::semantics::phase::ToExprOptions {
-            //         alpha: false,
-            //         normalize: true,
-            //     });
             let expr = parse_file_str(&expr_file_path)?
                 .resolve()?
-                .tck_and_normalize_new_flow()?
+                .typecheck()?
+                .normalize()
                 .to_expr();
             let expected = parse_file_str(&expected_file_path)?.to_expr();
 
diff --git a/dhall/tests/type-errors/hurkensParadox.txt b/dhall/tests/type-errors/hurkensParadox.txt
index 9342fd8..4dfdcf5 100644
--- a/dhall/tests/type-errors/hurkensParadox.txt
+++ b/dhall/tests/type-errors/hurkensParadox.txt
@@ -1 +1 @@
-Type error: Unhandled error: TypeMismatch
+Type error: Unhandled error: function annot mismatch: (U : Sort) : Kind
diff --git a/dhall/tests/type-errors/mixedUnions.txt b/dhall/tests/type-errors/mixedUnions.txt
index 30fcdf8..fd4de70 100644
--- a/dhall/tests/type-errors/mixedUnions.txt
+++ b/dhall/tests/type-errors/mixedUnions.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidFieldType(Label("Right"), Type)
+Type error: Unhandled error: InvalidFieldType
diff --git a/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldName.txt b/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldName.txt
index 045eb98..946b296 100644
--- a/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldName.txt
+++ b/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldName.txt
@@ -1 +1 @@
-Type error: Unhandled error: AnnotMismatch
+Type error: Unhandled error: annot mismatch: ({ x = 1 } : { x : Natural }) : { y : Natural }
diff --git a/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldType.txt b/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldType.txt
index 045eb98..89817db 100644
--- a/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldType.txt
+++ b/dhall/tests/type-errors/unit/AnnotationRecordWrongFieldType.txt
@@ -1 +1 @@
-Type error: Unhandled error: AnnotMismatch
+Type error: Unhandled error: annot mismatch: ({ x = 1 } : { x : Natural }) : { x : Text }
diff --git a/dhall/tests/type-errors/unit/AssertAlphaTrap.txt b/dhall/tests/type-errors/unit/AssertAlphaTrap.txt
index 2969c18..87cf48e 100644
--- a/dhall/tests/type-errors/unit/AssertAlphaTrap.txt
+++ b/dhall/tests/type-errors/unit/AssertAlphaTrap.txt
@@ -1,6 +1 @@
- --> 1:47
-  |
-1 | assert : (\(_: Bool) -> _) === (\(x: Bool) -> _)␊
-  |                                               ^
-  |
-  = Type error: Unbound variable
+Type error: Unhandled error: unbound variable
diff --git a/dhall/tests/type-errors/unit/EquivalenceNotTerms.txt b/dhall/tests/type-errors/unit/EquivalenceNotTerms.txt
index 7c48d6f..de11e28 100644
--- a/dhall/tests/type-errors/unit/EquivalenceNotTerms.txt
+++ b/dhall/tests/type-errors/unit/EquivalenceNotTerms.txt
@@ -1 +1 @@
-Type error: Unhandled error: EquivalenceArgumentMustBeTerm
+Type error: Unhandled error: EquivalenceArgumentsMustBeTerms
diff --git a/dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt b/dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt
index 9342fd8..8d101c3 100644
--- a/dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt
+++ b/dhall/tests/type-errors/unit/FunctionApplicationArgumentNotMatch.txt
@@ -1 +1 @@
-Type error: Unhandled error: TypeMismatch
+Type error: Unhandled error: function annot mismatch: (True : Bool) : Natural
diff --git a/dhall/tests/type-errors/unit/FunctionApplicationIsNotFunction.txt b/dhall/tests/type-errors/unit/FunctionApplicationIsNotFunction.txt
index f1cdf92..13b0819 100644
--- a/dhall/tests/type-errors/unit/FunctionApplicationIsNotFunction.txt
+++ b/dhall/tests/type-errors/unit/FunctionApplicationIsNotFunction.txt
@@ -1 +1 @@
-Type error: Unhandled error: NotAFunction
+Type error: Unhandled error: apply to not Pi: AppliedBuiltin(Bool, [], [], NzEnv { items: [] })
diff --git a/dhall/tests/type-errors/unit/FunctionArgumentTypeNotAType.txt b/dhall/tests/type-errors/unit/FunctionArgumentTypeNotAType.txt
index 9e43c33..a13fb3a 100644
--- a/dhall/tests/type-errors/unit/FunctionArgumentTypeNotAType.txt
+++ b/dhall/tests/type-errors/unit/FunctionArgumentTypeNotAType.txt
@@ -1,6 +1 @@
- --> 1:7
-  |
-1 | λ(_ : 1) → _␊
-  |       ^
-  |
-  = Type error: Invalid function input
+[unknown location] Type error: Invalid function input
diff --git a/dhall/tests/type-errors/unit/FunctionTypeArgumentTypeNotAType.txt b/dhall/tests/type-errors/unit/FunctionTypeArgumentTypeNotAType.txt
index dd2e758..a13fb3a 100644
--- a/dhall/tests/type-errors/unit/FunctionTypeArgumentTypeNotAType.txt
+++ b/dhall/tests/type-errors/unit/FunctionTypeArgumentTypeNotAType.txt
@@ -1,6 +1 @@
- --> 1:1
-  |
-1 | 2 → _␊
-  | ^
-  |
-  = Type error: Invalid function input
+[unknown location] Type error: Invalid function input
diff --git a/dhall/tests/type-errors/unit/LetWithWrongAnnotation.txt b/dhall/tests/type-errors/unit/LetWithWrongAnnotation.txt
index 045eb98..cae4fea 100644
--- a/dhall/tests/type-errors/unit/LetWithWrongAnnotation.txt
+++ b/dhall/tests/type-errors/unit/LetWithWrongAnnotation.txt
@@ -1 +1 @@
-Type error: Unhandled error: AnnotMismatch
+Type error: Unhandled error: annot mismatch: (True : Bool) : Natural
diff --git a/dhall/tests/type-errors/unit/ListLiteralEmptyNotType.txt b/dhall/tests/type-errors/unit/ListLiteralEmptyNotType.txt
index 9342fd8..070e461 100644
--- a/dhall/tests/type-errors/unit/ListLiteralEmptyNotType.txt
+++ b/dhall/tests/type-errors/unit/ListLiteralEmptyNotType.txt
@@ -1 +1 @@
-Type error: Unhandled error: TypeMismatch
+Type error: Unhandled error: function annot mismatch: (Type : Kind) : Type
diff --git a/dhall/tests/type-errors/unit/MergeHandlerFreeVar.txt b/dhall/tests/type-errors/unit/MergeHandlerFreeVar.txt
deleted file mode 100644
index de9e256..0000000
--- a/dhall/tests/type-errors/unit/MergeHandlerFreeVar.txt
+++ /dev/null
@@ -1 +0,0 @@
-Type error: Unhandled error: MergeHandlerReturnTypeMustNotBeDependent
diff --git a/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt b/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt
index 9342fd8..77fed39 100644
--- a/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt
+++ b/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt
@@ -1 +1,21 @@
-Type error: Unhandled error: TypeMismatch
+Type error: Unhandled error: MergeHandlerTypeMismatch: Value@WHNF {
+    value: AppliedBuiltin(
+        Natural,
+        [],
+        [],
+        NzEnv {
+            items: [],
+        },
+    ),
+    type: Type,
+} != Value@WHNF {
+    value: AppliedBuiltin(
+        Bool,
+        [],
+        [],
+        NzEnv {
+            items: [],
+        },
+    ),
+    type: Type,
+}
diff --git a/dhall/tests/type-errors/unit/MergeHandlersWithDifferentType.txt b/dhall/tests/type-errors/unit/MergeHandlersWithDifferentType.txt
index 8b729a4..02d2970 100644
--- a/dhall/tests/type-errors/unit/MergeHandlersWithDifferentType.txt
+++ b/dhall/tests/type-errors/unit/MergeHandlersWithDifferentType.txt
@@ -1 +1,65 @@
-Type error: Unhandled error: MergeHandlerTypeMismatch
+Type error: Unhandled error: MergeHandlerTypeMismatch: Value@WHNF {
+    value: AppliedBuiltin(
+        Bool,
+        [],
+        [],
+        NzEnv {
+            items: [
+                Replaced(
+                    Value@Unevaled {
+                        value: Var(
+                            AlphaVar(0),
+                            Fresh(
+                                119,
+                            ),
+                        ),
+                        type: Value@WHNF {
+                            value: AppliedBuiltin(
+                                Bool,
+                                [],
+                                [],
+                                NzEnv {
+                                    items: [],
+                                },
+                            ),
+                            type: Type,
+                        },
+                    },
+                ),
+            ],
+        },
+    ),
+    type: Type,
+} != Value@WHNF {
+    value: AppliedBuiltin(
+        Natural,
+        [],
+        [],
+        NzEnv {
+            items: [
+                Replaced(
+                    Value@Unevaled {
+                        value: Var(
+                            AlphaVar(0),
+                            Fresh(
+                                120,
+                            ),
+                        ),
+                        type: Value@WHNF {
+                            value: AppliedBuiltin(
+                                Natural,
+                                [],
+                                [],
+                                NzEnv {
+                                    items: [],
+                                },
+                            ),
+                            type: Type,
+                        },
+                    },
+                ),
+            ],
+        },
+    ),
+    type: Type,
+}
diff --git a/dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt b/dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt
index 9342fd8..8d101c3 100644
--- a/dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt
+++ b/dhall/tests/type-errors/unit/NaturalSubtractNotNatural.txt
@@ -1 +1 @@
-Type error: Unhandled error: TypeMismatch
+Type error: Unhandled error: function annot mismatch: (True : Bool) : Natural
diff --git a/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxPresent.txt b/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxPresent.txt
index 045eb98..91d7fb0 100644
--- a/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxPresent.txt
+++ b/dhall/tests/type-errors/unit/OptionalDeprecatedSyntaxPresent.txt
@@ -1 +1 @@
-Type error: Unhandled error: AnnotMismatch
+Type error: Unhandled error: annot mismatch: ([1] : List Natural) : Optional Natural
diff --git a/dhall/tests/type-errors/unit/RecordTypeValueMember.txt b/dhall/tests/type-errors/unit/RecordTypeValueMember.txt
index ed3fd6a..fd4de70 100644
--- a/dhall/tests/type-errors/unit/RecordTypeValueMember.txt
+++ b/dhall/tests/type-errors/unit/RecordTypeValueMember.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidFieldType(Label("x"), Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
+Type error: Unhandled error: InvalidFieldType
diff --git a/dhall/tests/type-errors/unit/TypeAnnotationWrong.txt b/dhall/tests/type-errors/unit/TypeAnnotationWrong.txt
index 045eb98..52fc94d 100644
--- a/dhall/tests/type-errors/unit/TypeAnnotationWrong.txt
+++ b/dhall/tests/type-errors/unit/TypeAnnotationWrong.txt
@@ -1 +1 @@
-Type error: Unhandled error: AnnotMismatch
+Type error: Unhandled error: annot mismatch: (1 : Natural) : Bool
diff --git a/dhall/tests/type-errors/unit/UnionDeprecatedConstructorsKeyword.txt b/dhall/tests/type-errors/unit/UnionDeprecatedConstructorsKeyword.txt
index 9cc0c19..87cf48e 100644
--- a/dhall/tests/type-errors/unit/UnionDeprecatedConstructorsKeyword.txt
+++ b/dhall/tests/type-errors/unit/UnionDeprecatedConstructorsKeyword.txt
@@ -1,6 +1 @@
- --> 1:1
-  |
-1 | constructors < Left : Natural | Right : Bool >␊
-  | ^----------^
-  |
-  = Type error: Unbound variable
+Type error: Unhandled error: unbound variable
diff --git a/dhall/tests/type-errors/unit/UnionTypeMixedKinds.txt b/dhall/tests/type-errors/unit/UnionTypeMixedKinds.txt
index 07604ba..fd4de70 100644
--- a/dhall/tests/type-errors/unit/UnionTypeMixedKinds.txt
+++ b/dhall/tests/type-errors/unit/UnionTypeMixedKinds.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidFieldType(Label("y"), Type)
+Type error: Unhandled error: InvalidFieldType
diff --git a/dhall/tests/type-errors/unit/UnionTypeMixedKinds2.txt b/dhall/tests/type-errors/unit/UnionTypeMixedKinds2.txt
index 07604ba..fd4de70 100644
--- a/dhall/tests/type-errors/unit/UnionTypeMixedKinds2.txt
+++ b/dhall/tests/type-errors/unit/UnionTypeMixedKinds2.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidFieldType(Label("y"), Type)
+Type error: Unhandled error: InvalidFieldType
diff --git a/dhall/tests/type-errors/unit/UnionTypeMixedKinds3.txt b/dhall/tests/type-errors/unit/UnionTypeMixedKinds3.txt
index ded0e5c..fd4de70 100644
--- a/dhall/tests/type-errors/unit/UnionTypeMixedKinds3.txt
+++ b/dhall/tests/type-errors/unit/UnionTypeMixedKinds3.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidFieldType(Label("y"), Value@Unevaled { value: AppliedBuiltin(Bool, [], []), type: Type })
+Type error: Unhandled error: InvalidFieldType
diff --git a/dhall/tests/type-errors/unit/UnionTypeNotType.txt b/dhall/tests/type-errors/unit/UnionTypeNotType.txt
index ed3fd6a..fd4de70 100644
--- a/dhall/tests/type-errors/unit/UnionTypeNotType.txt
+++ b/dhall/tests/type-errors/unit/UnionTypeNotType.txt
@@ -1 +1 @@
-Type error: Unhandled error: InvalidFieldType(Label("x"), Value@Unevaled { value: PartialExpr(BoolLit(true)), type: Value@WHNF { value: AppliedBuiltin(Bool, [], []), type: Type } })
+Type error: Unhandled error: InvalidFieldType
diff --git a/dhall/tests/type-errors/unit/VariableFree.txt b/dhall/tests/type-errors/unit/VariableFree.txt
index a46aac0..87cf48e 100644
--- a/dhall/tests/type-errors/unit/VariableFree.txt
+++ b/dhall/tests/type-errors/unit/VariableFree.txt
@@ -1,6 +1 @@
- --> 1:1
-  |
-1 | x␊
-  | ^
-  |
-  = Type error: Unbound variable
+Type error: Unhandled error: unbound variable
-- 
cgit v1.2.3


From e410dbb428e621fe600be43ddecca1c7bff7cb2f Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 29 Jan 2020 19:11:52 +0000
Subject: Fix insufficient normalization

---
 dhall/src/semantics/phase/mod.rs     |  4 +---
 dhall/src/semantics/tck/tyexpr.rs    | 10 +++++++++-
 dhall/src/semantics/tck/typecheck.rs | 12 ++++++------
 3 files changed, 16 insertions(+), 10 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/phase/mod.rs b/dhall/src/semantics/phase/mod.rs
index 0f8194c..2727a61 100644
--- a/dhall/src/semantics/phase/mod.rs
+++ b/dhall/src/semantics/phase/mod.rs
@@ -102,9 +102,7 @@ impl Resolved {
 impl Typed {
     /// Reduce an expression to its normal form, performing beta reduction
     pub fn normalize(&self) -> Normalized {
-        let mut val = self.0.normalize_whnf_noenv();
-        val.normalize_mut();
-        Normalized(val)
+        Normalized(self.0.normalize_nf_noenv())
     }
 
     /// Converts a value back to the corresponding AST expression.
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index 9e8dc47..e4108ad 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -67,7 +67,15 @@ impl TyExpr {
         normalize_tyexpr_whnf(self, env)
     }
     pub fn normalize_whnf_noenv(&self) -> Value {
-        normalize_tyexpr_whnf(self, &NzEnv::new())
+        self.normalize_whnf(&NzEnv::new())
+    }
+    pub fn normalize_nf(&self, env: &NzEnv) -> Value {
+        let mut val = self.normalize_whnf(env);
+        val.normalize_mut();
+        val
+    }
+    pub fn normalize_nf_noenv(&self) -> Value {
+        self.normalize_nf(&NzEnv::new())
     }
 }
 
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index 5880d92..abb36e1 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -150,7 +150,7 @@ fn type_one_layer(
             text_type
         }
         ExprKind::EmptyListLit(t) => {
-            let t = t.normalize_whnf(env.as_nzenv());
+            let t = t.normalize_nf(env.as_nzenv());
             match &*t.as_whnf() {
                 ValueKind::AppliedBuiltin(Builtin::List, args, _, _)
                     if args.len() == 1 => {}
@@ -250,7 +250,7 @@ fn type_one_layer(
                 },
                 // TODO: branch here only when scrut.get_type() is a Const
                 _ => {
-                    let scrut_nf = scrut.normalize_whnf(env.as_nzenv());
+                    let scrut_nf = scrut.normalize_nf(env.as_nzenv());
                     let scrut_nf_borrow = scrut_nf.as_whnf();
                     match &*scrut_nf_borrow {
                         ValueKind::UnionType(kts) => match kts.get(x) {
@@ -324,7 +324,7 @@ fn type_one_layer(
                         ));
                     }
 
-                    let arg_nf = arg.normalize_whnf(env.as_nzenv());
+                    let arg_nf = arg.normalize_nf(env.as_nzenv());
                     closure.apply(arg_nf)
                 }
                 _ => return mkerr(format!("apply to not Pi: {:?}", tf_borrow)),
@@ -387,7 +387,7 @@ fn type_one_layer(
             );
             let ty = type_one_layer(env, &ekind)?;
             TyExpr::new(TyExprKind::Expr(ekind), Some(ty), Span::Artificial)
-                .normalize_whnf(env.as_nzenv())
+                .normalize_nf(env.as_nzenv())
         }
         ExprKind::BinOp(BinOp::RecursiveRecordTypeMerge, x, y) => {
             let x_val = x.normalize_whnf(env.as_nzenv());
@@ -622,7 +622,7 @@ pub(crate) fn type_with(
         },
         ExprKind::Lam(binder, annot, body) => {
             let annot = type_with(env, annot)?;
-            let annot_nf = annot.normalize_whnf(env.as_nzenv());
+            let annot_nf = annot.normalize_nf(env.as_nzenv());
             let body_env = env.insert_type(&binder, annot_nf.clone());
             let body = type_with(&body_env, body)?;
             let body_ty = body.get_type()?;
@@ -660,7 +660,7 @@ pub(crate) fn type_with(
             };
 
             let val = type_with(env, &val)?;
-            let val_nf = val.normalize_whnf(&env.as_nzenv());
+            let val_nf = val.normalize_nf(&env.as_nzenv());
             let body = type_with(&env.insert_value(&binder, val_nf), body)?;
             let body_ty = body.get_type().ok();
             (
-- 
cgit v1.2.3


From db6c09f33c3c794e4b6ec8a7aa80978d945a9d7a Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 29 Jan 2020 21:26:42 +0000
Subject: Remove dead code

---
 dhall/src/error/mod.rs                 |  17 +-
 dhall/src/semantics/core/context.rs    |  95 -----
 dhall/src/semantics/core/value.rs      |  32 --
 dhall/src/semantics/core/visitor.rs    |   8 -
 dhall/src/semantics/nze/nzexpr.rs      | 411 +---------------------
 dhall/src/semantics/phase/normalize.rs |   7 -
 dhall/src/semantics/phase/typecheck.rs | 624 +--------------------------------
 dhall/src/semantics/tck/tyexpr.rs      |   5 -
 dhall/src/semantics/tck/typecheck.rs   |  30 +-
 dhall/src/syntax/ast/expr.rs           |   4 -
 10 files changed, 31 insertions(+), 1202 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index 5330c59..215a7bf 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -3,7 +3,7 @@ use std::io::Error as IOError;
 use crate::semantics::core::value::Value;
 use crate::semantics::phase::resolve::ImportStack;
 use crate::semantics::phase::NormalizedExpr;
-use crate::syntax::{Import, Label, ParseError, Span};
+use crate::syntax::{Import, ParseError};
 
 pub type Result<T> = std::result::Result<T, Error>;
 
@@ -45,7 +45,7 @@ pub struct TypeError {
 /// The specific type error
 #[derive(Debug)]
 pub(crate) enum TypeMessage {
-    UnboundVariable(Span),
+    // UnboundVariable(Span),
     InvalidInputType(Value),
     InvalidOutputType(Value),
     // NotAFunction(Value),
@@ -57,7 +57,7 @@ pub(crate) enum TypeMessage {
     // InvalidPredicate(Value),
     // IfBranchMismatch(Value, Value),
     // IfBranchMustBeTerm(bool, Value),
-    InvalidFieldType(Label, Value),
+    // InvalidFieldType(Label, Value),
     // NotARecord(Label, Value),
     // MustCombineRecord(Value),
     // MissingRecordField(Label, Value),
@@ -76,9 +76,9 @@ pub(crate) enum TypeMessage {
     // ProjectionMissingEntry,
     // ProjectionDuplicateField,
     Sort,
-    RecordTypeDuplicateField,
+    // RecordTypeDuplicateField,
     // RecordTypeMergeRequiresRecordType(Value),
-    UnionTypeDuplicateField,
+    // UnionTypeDuplicateField,
     // EquivalenceArgumentMustBeTerm(bool, Value),
     // EquivalenceTypeMismatch(Value, Value),
     // AssertMismatch(Value, Value),
@@ -96,7 +96,7 @@ impl std::fmt::Display for TypeError {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         use TypeMessage::*;
         let msg = match &self.message {
-            UnboundVariable(var) => var.error("Type error: Unbound variable"),
+            // UnboundVariable(var) => var.error("Type error: Unbound variable"),
             InvalidInputType(v) => {
                 v.span().error("Type error: Invalid function input")
             }
@@ -171,8 +171,3 @@ impl From<TypeError> for Error {
         Error::Typecheck(err)
     }
 }
-impl From<crate::semantics::nze::nzexpr::TypeError> for Error {
-    fn from(_: crate::semantics::nze::nzexpr::TypeError) -> Error {
-        Error::Decode(DecodeError::WrongFormatError("type error".to_string()))
-    }
-}
diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index 9749c50..8b13789 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -1,96 +1 @@
-use crate::error::TypeError;
-use crate::semantics::core::value::Value;
-use crate::semantics::core::value::ValueKind;
-use crate::semantics::core::var::{AlphaVar, Binder};
-use crate::semantics::nze::NzVar;
-// use crate::semantics::phase::normalize::{NzEnv, NzEnvItem};
-use crate::syntax::{Label, V};
 
-#[derive(Debug, Clone)]
-enum CtxItem {
-    // Variable is bound with given type
-    Kept(Value),
-    // Variable has been replaced by corresponding value
-    Replaced(Value),
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct TyCtx {
-    ctx: Vec<(Binder, CtxItem)>,
-}
-
-impl TyCtx {
-    pub fn new() -> Self {
-        TyCtx { ctx: Vec::new() }
-    }
-    fn with_vec(&self, vec: Vec<(Binder, CtxItem)>) -> Self {
-        TyCtx { ctx: vec }
-    }
-    pub fn insert_type(&self, x: &Binder, t: Value) -> Self {
-        let mut vec = self.ctx.clone();
-        vec.push((x.clone(), CtxItem::Kept(t.under_binder())));
-        self.with_vec(vec)
-    }
-    pub fn insert_value(
-        &self,
-        x: &Binder,
-        e: Value,
-    ) -> Result<Self, TypeError> {
-        let mut vec = self.ctx.clone();
-        vec.push((x.clone(), CtxItem::Replaced(e)));
-        Ok(self.with_vec(vec))
-    }
-    pub fn lookup(&self, var: &V<Label>) -> Option<Value> {
-        let mut var = var.clone();
-        let mut shift_delta: isize = 0;
-        let mut rev_ctx = self.ctx.iter().rev().map(|(b, i)| (b.to_label(), i));
-        let found_item = loop {
-            if let Some((label, item)) = rev_ctx.next() {
-                var = match var.over_binder(&label) {
-                    Some(newvar) => newvar,
-                    None => break item,
-                };
-                if let CtxItem::Kept(_) = item {
-                    shift_delta += 1;
-                }
-            } else {
-                // Unbound variable
-                return None;
-            }
-        };
-        let var_idx = rev_ctx
-            .filter(|(_, i)| match i {
-                CtxItem::Kept(_) => true,
-                CtxItem::Replaced(_) => false,
-            })
-            .count();
-
-        let v = match found_item {
-            CtxItem::Kept(t) => Value::from_kind_and_type(
-                ValueKind::Var(AlphaVar::default(), NzVar::new(var_idx)),
-                t.clone(),
-            ),
-            CtxItem::Replaced(v) => v.clone()
-                // .normalize_whnf(&NzEnv::construct(
-                //     self.ctx
-                //         .iter()
-                //         .filter_map(|(_, i)| match i {
-                //             CtxItem::Kept(t) => {
-                //                 Some(NzEnvItem::Kept(t.clone()))
-                //             }
-                //             CtxItem::Replaced(_) => None,
-                //         })
-                //         .collect(),
-                // )),
-        };
-        // Can't fail because delta is positive
-        let v = v.shift(shift_delta, &AlphaVar::default()).unwrap();
-        return Some(v);
-    }
-    // pub fn lookup_alpha(&self, var: &AlphaVar) -> Option<Value> {
-    //     self.lookup(&var.normal)
-    // }
-    pub fn new_binder(&self, l: &Label) -> Binder {
-        Binder::new(l.clone())
-    }
-}
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index aa819d2..30c4116 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -68,8 +68,6 @@ pub(crate) enum Closure {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum ValueKind<Value> {
     /// Closures
-    Lam(Binder, Value, Value),
-    Pi(Binder, Value, Value),
     LamClosure {
         binder: Binder,
         annot: Value,
@@ -133,13 +131,6 @@ impl Value {
     pub(crate) fn from_kind_and_type(v: ValueKind<Value>, t: Value) -> Value {
         Value::new(v, Unevaled, t, Span::Artificial)
     }
-    pub(crate) fn from_kind_and_type_and_span(
-        v: ValueKind<Value>,
-        t: Value,
-        span: Span,
-    ) -> Value {
-        Value::new(v, Unevaled, t, span)
-    }
     pub(crate) fn from_kind_and_type_whnf(
         v: ValueKind<Value>,
         t: Value,
@@ -155,10 +146,6 @@ impl Value {
     pub(crate) fn from_builtin_env(b: Builtin, env: &NzEnv) -> Self {
         builtin_to_value_env(b, env)
     }
-    pub(crate) fn with_span(self, span: Span) -> Self {
-        self.as_internal_mut().span = span;
-        self
-    }
 
     pub(crate) fn as_const(&self) -> Option<Const> {
         match &*self.as_whnf() {
@@ -238,10 +225,6 @@ impl Value {
 
     pub(crate) fn app(&self, v: Value) -> Value {
         let body_t = match &*self.get_type_not_sort().as_whnf() {
-            ValueKind::Pi(_, t, e) => {
-                v.check_type(t);
-                e.subst_shift(&AlphaVar::default(), &v)
-            }
             ValueKind::PiClosure { annot, closure, .. } => {
                 v.check_type(annot);
                 closure.apply(v.clone())
@@ -276,9 +259,6 @@ impl Value {
     pub(crate) fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
         Some(self.as_internal().shift(delta, var)?.into_value())
     }
-    pub(crate) fn over_binder(&self) -> Option<Self> {
-        self.shift(-1, &AlphaVar::default())
-    }
     pub(crate) fn under_binder(&self) -> Self {
         // Can't fail since delta is positive
         self.shift(1, &AlphaVar::default()).unwrap()
@@ -398,10 +378,6 @@ impl Value {
                     | ValueKind::AppliedBuiltin(..)
                     | ValueKind::UnionConstructor(..)
                     | ValueKind::UnionLit(..) => unreachable!(),
-                    ValueKind::Lam(x, t, e) => {
-                        ExprKind::Lam(x.to_label(), t, e)
-                    }
-                    ValueKind::Pi(x, t, e) => ExprKind::Pi(x.to_label(), t, e),
                     ValueKind::Const(c) => ExprKind::Const(c),
                     ValueKind::BoolLit(b) => ExprKind::BoolLit(b),
                     ValueKind::NaturalLit(n) => ExprKind::NaturalLit(n),
@@ -555,14 +531,6 @@ impl ValueKind<Value> {
             ValueKind::NEOptionalLit(th) => {
                 th.normalize_mut();
             }
-            ValueKind::Lam(_, t, e) => {
-                t.normalize_mut();
-                e.normalize_mut();
-            }
-            ValueKind::Pi(_, t, e) => {
-                t.normalize_mut();
-                e.normalize_mut();
-            }
             ValueKind::LamClosure { annot, .. }
             | ValueKind::PiClosure { annot, .. } => {
                 annot.normalize_mut();
diff --git a/dhall/src/semantics/core/visitor.rs b/dhall/src/semantics/core/visitor.rs
index 61a7d0b..aec66f8 100644
--- a/dhall/src/semantics/core/visitor.rs
+++ b/dhall/src/semantics/core/visitor.rs
@@ -72,14 +72,6 @@ where
 {
     use ValueKind::*;
     Ok(match input {
-        Lam(l, t, e) => {
-            let (t, e) = v.visit_binder(l, t, e)?;
-            Lam(l.clone(), t, e)
-        }
-        Pi(l, t, e) => {
-            let (t, e) = v.visit_binder(l, t, e)?;
-            Pi(l.clone(), t, e)
-        }
         LamClosure {
             binder,
             annot,
diff --git a/dhall/src/semantics/nze/nzexpr.rs b/dhall/src/semantics/nze/nzexpr.rs
index 92ba8fd..043840e 100644
--- a/dhall/src/semantics/nze/nzexpr.rs
+++ b/dhall/src/semantics/nze/nzexpr.rs
@@ -1,76 +1,8 @@
-#![allow(dead_code)]
 use crate::semantics::core::var::AlphaVar;
-use crate::semantics::phase::typecheck::rc;
-use crate::semantics::phase::{Normalized, NormalizedExpr, ToExprOptions};
-use crate::syntax::{Expr, ExprKind, Label, V};
+use crate::syntax::{Label, V};
 
-pub(crate) type Type = NzExpr;
-#[derive(Debug, Clone)]
-pub(crate) struct TypeError;
 pub(crate) type Binder = Label;
 
-// An expression with inferred types at every node and resolved variables.
-#[derive(Debug, Clone)]
-pub(crate) struct TyExpr {
-    kind: Box<TyExprKind>,
-    ty: Option<Type>,
-}
-
-#[derive(Debug, Clone)]
-pub(crate) enum TyExprKind {
-    Var(AlphaVar),
-    Expr(ExprKind<TyExpr, Normalized>),
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct NzExpr {
-    kind: Box<NzExprKind>,
-    ty: Option<Box<Type>>,
-}
-
-#[derive(Debug, Clone)]
-pub(crate) enum NzExprKind {
-    Var {
-        var: NzVar,
-    },
-    Lam {
-        binder: Binder,
-        annot: NzExpr,
-        env: NzEnv,
-        body: TyExpr,
-    },
-    Pi {
-        binder: Binder,
-        annot: NzExpr,
-        env: NzEnv,
-        body: TyExpr,
-    },
-    Expr(ExprKind<NzExpr, Normalized>),
-    // Unevaled {
-    //     env: NzEnv,
-    //     expr: TyExprKind,
-    // },
-}
-
-#[derive(Debug, Clone)]
-enum NzEnvItem {
-    // Variable is bound with given type
-    Kept(Type),
-    // Variable has been replaced by corresponding value
-    Replaced(NzExpr),
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct TyEnv {
-    names: NameEnv,
-    items: NzEnv,
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct NzEnv {
-    items: Vec<NzEnvItem>,
-}
-
 #[derive(Debug, Clone)]
 pub(crate) struct NameEnv {
     names: Vec<Binder>,
@@ -88,54 +20,6 @@ pub(crate) enum NzVar {
     /// Fake fresh variable generated for expression equality checking.
     Fresh(usize),
 }
-// TODO: temporary hopefully
-// impl std::cmp::PartialEq for NzVar {
-//     fn eq(&self, _other: &Self) -> bool {
-//         true
-//     }
-// }
-
-impl TyEnv {
-    pub fn new() -> Self {
-        TyEnv {
-            names: NameEnv::new(),
-            items: NzEnv::new(),
-        }
-    }
-    pub fn as_quoteenv(&self) -> QuoteEnv {
-        self.names.as_quoteenv()
-    }
-    pub fn as_nzenv(&self) -> &NzEnv {
-        &self.items
-    }
-    pub fn as_nameenv(&self) -> &NameEnv {
-        &self.names
-    }
-
-    pub fn insert_type(&self, x: &Binder, t: NzExpr) -> Self {
-        TyEnv {
-            names: self.names.insert(x),
-            items: self.items.insert_type(t),
-        }
-    }
-    pub fn insert_value(&self, x: &Binder, e: NzExpr) -> Self {
-        TyEnv {
-            names: self.names.insert(x),
-            items: self.items.insert_value(e),
-        }
-    }
-    pub fn lookup_var(&self, var: &V<Binder>) -> Option<TyExpr> {
-        let var = self.names.unlabel_var(var)?;
-        let ty = self.lookup_val(&var).get_type().unwrap();
-        Some(TyExpr::new(TyExprKind::Var(var), Some(ty)))
-    }
-    pub fn lookup_val(&self, var: &AlphaVar) -> NzExpr {
-        self.items.lookup_val(var)
-    }
-    pub fn size(&self) -> usize {
-        self.names.size()
-    }
-}
 
 impl NameEnv {
     pub fn new() -> Self {
@@ -163,9 +47,9 @@ impl NameEnv {
     pub fn insert_mut(&mut self, x: &Binder) {
         self.names.push(x.clone())
     }
-    pub fn remove_mut(&mut self) {
-        self.names.pop();
-    }
+    // pub fn remove_mut(&mut self) {
+    //     self.names.pop();
+    // }
 
     pub fn unlabel_var(&self, var: &V<Binder>) -> Option<AlphaVar> {
         let V(name, idx) = var;
@@ -178,50 +62,17 @@ impl NameEnv {
             .nth(*idx)?;
         Some(AlphaVar::new(V((), idx)))
     }
-    pub fn label_var(&self, var: &AlphaVar) -> V<Binder> {
-        let name = &self.names[self.names.len() - 1 - var.idx()];
-        let idx = self
-            .names
-            .iter()
-            .rev()
-            .take(var.idx())
-            .filter(|n| *n == name)
-            .count();
-        V(name.clone(), idx)
-    }
-    pub fn size(&self) -> usize {
-        self.names.len()
-    }
-}
-
-impl NzEnv {
-    pub fn new() -> Self {
-        NzEnv { items: Vec::new() }
-    }
-
-    pub fn insert_type(&self, t: NzExpr) -> Self {
-        let mut env = self.clone();
-        env.items.push(NzEnvItem::Kept(t));
-        env
-    }
-    pub fn insert_value(&self, e: NzExpr) -> Self {
-        let mut env = self.clone();
-        env.items.push(NzEnvItem::Replaced(e));
-        env
-    }
-    pub fn lookup_val(&self, var: &AlphaVar) -> NzExpr {
-        // TODO: use VarEnv
-        let idx = self.items.len() - 1 - var.idx();
-        match &self.items[idx] {
-            NzEnvItem::Kept(ty) => NzExpr::new(
-                NzExprKind::Var {
-                    var: NzVar::new(idx),
-                },
-                Some(ty.clone()),
-            ),
-            NzEnvItem::Replaced(x) => x.clone(),
-        }
-    }
+    // pub fn label_var(&self, var: &AlphaVar) -> V<Binder> {
+    //     let name = &self.names[self.names.len() - 1 - var.idx()];
+    //     let idx = self
+    //         .names
+    //         .iter()
+    //         .rev()
+    //         .take(var.idx())
+    //         .filter(|n| *n == name)
+    //         .count();
+    //     V(name.clone(), idx)
+    // }
 }
 
 // TODO: rename to VarEnv
@@ -229,9 +80,6 @@ impl QuoteEnv {
     pub fn new() -> Self {
         QuoteEnv { size: 0 }
     }
-    pub fn construct(size: usize) -> Self {
-        QuoteEnv { size }
-    }
     pub fn size(&self) -> usize {
         self.size
     }
@@ -273,232 +121,3 @@ impl NzVar {
         }
     }
 }
-
-impl TyExpr {
-    pub fn new(kind: TyExprKind, ty: Option<Type>) -> Self {
-        TyExpr {
-            kind: Box::new(kind),
-            ty,
-        }
-    }
-
-    pub fn kind(&self) -> &TyExprKind {
-        self.kind.as_ref()
-    }
-    pub fn get_type(&self) -> Result<Type, TypeError> {
-        match &self.ty {
-            Some(t) => Ok(t.clone()),
-            None => Err(TypeError),
-        }
-    }
-
-    /// Converts a value back to the corresponding AST expression.
-    pub fn to_expr(&self, opts: ToExprOptions) -> NormalizedExpr {
-        if opts.alpha {
-            self.to_expr_alpha()
-        } else {
-            self.to_expr_noalpha(&mut NameEnv::new())
-        }
-    }
-    fn to_expr_noalpha(&self, env: &mut NameEnv) -> NormalizedExpr {
-        rc(match self.kind() {
-            TyExprKind::Var(var) => ExprKind::Var(env.label_var(var)),
-            TyExprKind::Expr(e) => e.map_ref_maybe_binder(|l, tye| {
-                if let Some(l) = l {
-                    env.insert_mut(l);
-                }
-                let e = tye.to_expr_noalpha(env);
-                if let Some(_) = l {
-                    env.remove_mut();
-                }
-                e
-            }),
-        })
-    }
-    fn to_expr_alpha(&self) -> NormalizedExpr {
-        rc(match self.kind() {
-            TyExprKind::Var(var) => ExprKind::Var(V("_".into(), var.idx())),
-            TyExprKind::Expr(e) => match e.map_ref(TyExpr::to_expr_alpha) {
-                ExprKind::Lam(_, t, e) => ExprKind::Lam("_".into(), t, e),
-                ExprKind::Pi(_, t, e) => ExprKind::Pi("_".into(), t, e),
-                e => e,
-            },
-        })
-    }
-
-    pub fn normalize_nf(&self, env: &NzEnv) -> NzExpr {
-        let kind = match self.kind() {
-            TyExprKind::Var(var) => return env.lookup_val(var),
-            TyExprKind::Expr(ExprKind::Lam(binder, annot, body)) => {
-                NzExprKind::Lam {
-                    binder: binder.clone(),
-                    annot: annot.normalize_nf(env),
-                    env: env.clone(),
-                    body: body.clone(),
-                }
-            }
-            TyExprKind::Expr(ExprKind::Pi(binder, annot, body)) => {
-                NzExprKind::Pi {
-                    binder: binder.clone(),
-                    annot: annot.normalize_nf(env),
-                    env: env.clone(),
-                    body: body.clone(),
-                }
-            }
-            TyExprKind::Expr(e) => {
-                let e = e.map_ref(|tye| tye.normalize_nf(env));
-                match e {
-                    ExprKind::App(f, arg) => match f.kind() {
-                        NzExprKind::Lam { env, body, .. } => {
-                            return body.normalize_nf(&env.insert_value(arg))
-                        }
-                        _ => NzExprKind::Expr(ExprKind::App(f, arg)),
-                    },
-                    _ => NzExprKind::Expr(e),
-                }
-            }
-        };
-        let ty = self.ty.clone();
-        NzExpr::new(kind, ty)
-    }
-
-    pub fn normalize(&self) -> NzExpr {
-        self.normalize_nf(&NzEnv::new())
-    }
-}
-
-impl NzExpr {
-    pub fn new(kind: NzExprKind, ty: Option<Type>) -> Self {
-        NzExpr {
-            kind: Box::new(kind),
-            ty: ty.map(Box::new),
-        }
-    }
-
-    pub fn kind(&self) -> &NzExprKind {
-        self.kind.as_ref()
-    }
-    pub fn get_type(&self) -> Result<Type, TypeError> {
-        match &self.ty {
-            Some(t) => Ok(t.as_ref().clone()),
-            None => Err(TypeError),
-        }
-    }
-
-    pub fn quote(&self, qenv: QuoteEnv) -> TyExpr {
-        let ty = self.ty.as_ref().map(|t| (**t).clone());
-        let kind = match self.kind.as_ref() {
-            NzExprKind::Var { var } => TyExprKind::Var(qenv.lookup(var)),
-            NzExprKind::Lam {
-                binder,
-                annot,
-                env,
-                body,
-            } => TyExprKind::Expr(ExprKind::Lam(
-                binder.clone(),
-                annot.quote(qenv),
-                body.normalize_nf(&env.insert_type(annot.clone()))
-                    .quote(qenv.insert()),
-            )),
-            NzExprKind::Pi {
-                binder,
-                annot,
-                env,
-                body,
-            } => TyExprKind::Expr(ExprKind::Pi(
-                binder.clone(),
-                annot.quote(qenv),
-                body.normalize_nf(&env.insert_type(annot.clone()))
-                    .quote(qenv.insert()),
-            )),
-            NzExprKind::Expr(e) => {
-                TyExprKind::Expr(e.map_ref(|nze| nze.quote(qenv)))
-            } // NzExprKind::Unevaled { env, expr } => {
-              //     return TyExpr::new(expr.clone(), ty.clone())
-              //         .normalize_nf(env)
-              //         .quote(qenv)
-              // }
-        };
-        TyExpr::new(kind, ty)
-    }
-    pub fn to_expr(&self) -> NormalizedExpr {
-        self.quote(QuoteEnv::new()).to_expr(ToExprOptions {
-            alpha: false,
-            normalize: false,
-        })
-    }
-}
-
-/// Type-check an expression and return the expression alongside its type if type-checking
-/// succeeded, or an error if type-checking failed.
-fn type_with(env: &TyEnv, e: Expr<Normalized>) -> Result<TyExpr, TypeError> {
-    match e.as_ref() {
-        ExprKind::Var(var) => match env.lookup_var(&var) {
-            Some(x) => Ok(x),
-            None => Err(TypeError),
-        },
-        ExprKind::Lam(binder, annot, body) => {
-            let annot = type_with(env, annot.clone())?;
-            let annot_nf = annot.normalize_nf(env.as_nzenv());
-            let body = type_with(
-                &env.insert_type(&binder, annot_nf.clone()),
-                body.clone(),
-            )?;
-            let ty = NzExpr::new(
-                NzExprKind::Pi {
-                    binder: binder.clone(),
-                    annot: annot_nf,
-                    env: env.as_nzenv().clone(),
-                    body: body.get_type()?.quote(env.as_quoteenv()),
-                },
-                None, // TODO: function_check
-            );
-            Ok(TyExpr::new(
-                TyExprKind::Expr(ExprKind::Lam(binder.clone(), annot, body)),
-                Some(ty),
-            ))
-        }
-        ExprKind::Pi(binder, annot, body) => {
-            let annot = type_with(env, annot.clone())?;
-            let annot_nf = annot.normalize_nf(env.as_nzenv());
-            let body = type_with(
-                &env.insert_type(&binder, annot_nf.clone()),
-                body.clone(),
-            )?;
-            Ok(TyExpr::new(
-                TyExprKind::Expr(ExprKind::Pi(binder.clone(), annot, body)),
-                None, // TODO: function_check
-            ))
-        }
-        ExprKind::App(f, arg) => {
-            let f = type_with(env, f.clone())?;
-            let arg = type_with(env, arg.clone())?;
-            let tf = f.get_type()?;
-            let (_expected_arg_ty, body_env, body_ty) = match tf.kind() {
-                NzExprKind::Pi {
-                    annot, env, body, ..
-                } => (annot, env, body),
-                _ => return Err(TypeError),
-            };
-            // if arg.get_type()? != *expected_arg_ty {
-            //     return Err(TypeError);
-            // }
-
-            let arg_nf = arg.normalize_nf(env.as_nzenv());
-            let ty = body_ty.normalize_nf(&body_env.insert_value(arg_nf));
-
-            Ok(TyExpr::new(
-                TyExprKind::Expr(ExprKind::App(f, arg)),
-                Some(ty),
-            ))
-        }
-        e => Ok(TyExpr::new(
-            TyExprKind::Expr(e.traverse_ref(|e| type_with(env, e.clone()))?),
-            None,
-        )),
-    }
-}
-
-pub(crate) fn typecheck(e: Expr<Normalized>) -> Result<TyExpr, TypeError> {
-    type_with(&TyEnv::new(), e)
-}
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index f4e4099..d40456b 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -1,4 +1,3 @@
-#![allow(dead_code)]
 use std::collections::HashMap;
 use std::convert::TryInto;
 
@@ -376,9 +375,6 @@ pub(crate) fn apply_builtin(
 pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
     let f_borrow = f.as_whnf();
     match &*f_borrow {
-        ValueKind::Lam(_, _, e) => e
-            .subst_shift(&AlphaVar::default(), &a)
-            .to_whnf_check_type(ty),
         ValueKind::LamClosure { closure, .. } => {
             closure.apply(a).to_whnf_check_type(ty)
         }
@@ -861,9 +857,6 @@ impl NzEnv {
     pub fn new() -> Self {
         NzEnv { items: Vec::new() }
     }
-    pub fn construct(items: Vec<NzEnvItem>) -> Self {
-        NzEnv { items }
-    }
     pub fn to_alpha_tyenv(&self) -> TyEnv {
         TyEnv::from_nzenv_alpha(self)
     }
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index 6de65e8..4392365 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -1,122 +1,10 @@
-use std::borrow::Cow;
-use std::cmp::max;
-use std::collections::HashMap;
-
-use crate::error::{TypeError, TypeMessage};
-use crate::semantics::core::context::TyCtx;
-use crate::semantics::phase::normalize::merge_maps;
 use crate::semantics::phase::normalize::NzEnv;
-use crate::semantics::phase::Normalized;
-use crate::semantics::{AlphaVar, Binder, Value, ValueKind};
+use crate::semantics::{Value, ValueKind};
 use crate::syntax;
 use crate::syntax::{
-    Builtin, Const, Expr, ExprKind, InterpolatedTextContents, Label, Span,
-    UnspannedExpr,
+    Builtin, Const, Expr, ExprKind, Label, Span, UnspannedExpr,
 };
 
-fn tck_pi_type(
-    binder: Binder,
-    tx: Value,
-    te: Value,
-) -> Result<Value, TypeError> {
-    use TypeMessage::*;
-
-    let ka = match tx.get_type()?.as_const() {
-        Some(k) => k,
-        _ => return Err(TypeError::new(InvalidInputType(tx))),
-    };
-
-    let kb = match te.get_type()?.as_const() {
-        Some(k) => k,
-        _ => return Err(TypeError::new(InvalidOutputType(te.get_type()?))),
-    };
-
-    let k = function_check(ka, kb);
-
-    Ok(Value::from_kind_and_type(
-        ValueKind::Pi(binder, tx, te),
-        Value::from_const(k),
-    ))
-}
-
-fn tck_record_type(
-    kts: impl IntoIterator<Item = Result<(Label, Value), TypeError>>,
-) -> Result<Value, TypeError> {
-    use std::collections::hash_map::Entry;
-    use TypeMessage::*;
-    let mut new_kts = HashMap::new();
-    // An empty record type has type Type
-    let mut k = Const::Type;
-    for e in kts {
-        let (x, t) = e?;
-        // Construct the union of the contained `Const`s
-        match t.get_type()?.as_const() {
-            Some(k2) => k = max(k, k2),
-            None => return Err(TypeError::new(InvalidFieldType(x, t))),
-        }
-        // Check for duplicated entries
-        let entry = new_kts.entry(x);
-        match &entry {
-            Entry::Occupied(_) => {
-                return Err(TypeError::new(RecordTypeDuplicateField))
-            }
-            Entry::Vacant(_) => entry.or_insert_with(|| t),
-        };
-    }
-
-    Ok(Value::from_kind_and_type(
-        ValueKind::RecordType(new_kts),
-        Value::from_const(k),
-    ))
-}
-
-fn tck_union_type<Iter>(kts: Iter) -> Result<Value, TypeError>
-where
-    Iter: IntoIterator<Item = Result<(Label, Option<Value>), TypeError>>,
-{
-    use std::collections::hash_map::Entry;
-    use TypeMessage::*;
-    let mut new_kts = HashMap::new();
-    // Check that all types are the same const
-    let mut k = None;
-    for e in kts {
-        let (x, t) = e?;
-        if let Some(t) = &t {
-            match (k, t.get_type()?.as_const()) {
-                (None, Some(k2)) => k = Some(k2),
-                (Some(k1), Some(k2)) if k1 == k2 => {}
-                _ => {
-                    return Err(TypeError::new(InvalidFieldType(x, t.clone())))
-                }
-            }
-        }
-        let entry = new_kts.entry(x);
-        match &entry {
-            Entry::Occupied(_) => {
-                return Err(TypeError::new(UnionTypeDuplicateField))
-            }
-            Entry::Vacant(_) => entry.or_insert_with(|| t),
-        };
-    }
-
-    // An empty union type has type Type;
-    // an union type with only unary variants also has type Type
-    let k = k.unwrap_or(Const::Type);
-
-    Ok(Value::from_kind_and_type(
-        ValueKind::UnionType(new_kts),
-        Value::from_const(k),
-    ))
-}
-
-fn function_check(a: Const, b: Const) -> Const {
-    if b == Const::Type {
-        Const::Type
-    } else {
-        max(a, b)
-    }
-}
-
 pub(crate) fn const_to_value(c: Const) -> Value {
     let v = ValueKind::Const(c);
     match c {
@@ -289,511 +177,3 @@ pub(crate) fn builtin_to_value_env(b: Builtin, env: &NzEnv) -> Value {
             .normalize_whnf_noenv(),
     )
 }
-
-/// Type-check an expression and return the expression alongside its type if type-checking
-/// succeeded, or an error if type-checking failed.
-/// Some normalization is done while typechecking, so the returned expression might be partially
-/// normalized as well.
-fn type_with(ctx: &TyCtx, e: Expr<Normalized>) -> Result<Value, TypeError> {
-    use syntax::ExprKind::{Annot, Embed, Lam, Let, Pi, Var};
-    let span = e.span();
-
-    match e.as_ref() {
-        Lam(var, annot, body) => {
-            let binder = ctx.new_binder(var);
-            let annot = type_with(ctx, annot.clone())?;
-            annot.normalize_nf();
-            let ctx2 = ctx.insert_type(&binder, annot.clone());
-            let body = type_with(&ctx2, body.clone())?;
-            let body_type = body.get_type()?;
-            Ok(Value::from_kind_and_type(
-                ValueKind::Lam(binder.clone(), annot.clone(), body),
-                tck_pi_type(binder, annot, body_type)?,
-            ))
-        }
-        Pi(x, ta, tb) => {
-            let binder = ctx.new_binder(x);
-            let ta = type_with(ctx, ta.clone())?;
-            let ctx2 = ctx.insert_type(&binder, ta.clone());
-            let tb = type_with(&ctx2, tb.clone())?;
-            tck_pi_type(binder, ta, tb)
-        }
-        Let(x, t, v, e) => {
-            let v = if let Some(t) = t {
-                t.rewrap(Annot(v.clone(), t.clone()))
-            } else {
-                v.clone()
-            };
-
-            let v = type_with(ctx, v)?;
-            let binder = ctx.new_binder(x);
-            let e =
-                type_with(&ctx.insert_value(&binder, v.clone())?, e.clone())?;
-            // let e_ty = e.get_type()?;
-            // Ok(Value::from_kind_and_type(
-            //     ValueKind::PartialExpr(ExprKind::Let(x.clone(), None, v, e)),
-            //     e_ty,
-            // ))
-            Ok(e)
-        }
-        Embed(p) => Ok(p.clone().into_value()),
-        Var(var) => match ctx.lookup(&var) {
-            Some(typed) => Ok(typed.clone()),
-            None => Err(TypeError::new(TypeMessage::UnboundVariable(span))),
-        },
-        e => {
-            // Typecheck recursively all subexpressions
-            let expr = e.traverse_ref_with_special_handling_of_binders(
-                |e| type_with(ctx, e.clone()),
-                |_, _| unreachable!(),
-            )?;
-            type_last_layer(ctx, expr, span)
-        }
-    }
-}
-
-/// When all sub-expressions have been typed, check the remaining toplevel
-/// layer.
-fn type_last_layer(
-    ctx: &TyCtx,
-    e: ExprKind<Value, Normalized>,
-    span: Span,
-) -> Result<Value, TypeError> {
-    use syntax::BinOp::*;
-    use syntax::Builtin::*;
-    use syntax::Const::Type;
-    let mkerr =
-        |msg: &str| Err(TypeError::new(TypeMessage::Custom(msg.to_string())));
-
-    /// Intermediary return type
-    enum Ret {
-        /// Returns the contained value as is
-        RetWhole(Value),
-        /// Returns the input expression `e` with the contained value as its type
-        RetTypeOnly(Value),
-    }
-    use Ret::*;
-
-    let ret = match &e {
-        ExprKind::Import(_) => unreachable!(
-            "There should remain no imports in a resolved expression"
-        ),
-        ExprKind::Lam(_, _, _)
-        | ExprKind::Pi(_, _, _)
-        | ExprKind::Let(_, _, _, _)
-        | ExprKind::Embed(_)
-        | ExprKind::Var(_) => unreachable!(),
-        ExprKind::App(f, a) => {
-            let tf = f.get_type()?;
-            let tf_borrow = tf.as_whnf();
-            match &*tf_borrow {
-                ValueKind::Pi(_, tx, tb) => {
-                    if &a.get_type()? != tx {
-                        return mkerr("TypeMismatch");
-                    }
-
-                    let ret = tb.subst_shift(&AlphaVar::default(), a);
-                    ret.normalize_nf();
-                    RetTypeOnly(ret)
-                }
-                ValueKind::PiClosure { closure, .. } => {
-                    RetTypeOnly(closure.apply(a.clone()))
-                }
-                _ => return mkerr("NotAFunction"),
-            }
-        }
-        ExprKind::Annot(x, t) => {
-            if &x.get_type()? != t {
-                return mkerr("AnnotMismatch");
-            }
-            RetWhole(x.clone())
-        }
-        ExprKind::Assert(t) => {
-            match &*t.as_whnf() {
-                ValueKind::Equivalence(x, y) if x == y => {}
-                ValueKind::Equivalence(..) => return mkerr("AssertMismatch"),
-                _ => return mkerr("AssertMustTakeEquivalence"),
-            }
-            RetTypeOnly(t.clone())
-        }
-        ExprKind::BoolIf(x, y, z) => {
-            if *x.get_type()?.as_whnf() != ValueKind::from_builtin(Bool) {
-                return mkerr("InvalidPredicate");
-            }
-
-            if y.get_type()?.get_type()?.as_const() != Some(Const::Type) {
-                return mkerr("IfBranchMustBeTerm");
-            }
-
-            if z.get_type()?.get_type()?.as_const() != Some(Const::Type) {
-                return mkerr("IfBranchMustBeTerm");
-            }
-
-            if y.get_type()? != z.get_type()? {
-                return mkerr("IfBranchMismatch");
-            }
-
-            RetTypeOnly(y.get_type()?)
-        }
-        ExprKind::EmptyListLit(t) => {
-            let arg = match &*t.as_whnf() {
-                ValueKind::AppliedBuiltin(
-                    syntax::Builtin::List,
-                    args,
-                    _,
-                    _,
-                ) if args.len() == 1 => args[0].clone(),
-                _ => return mkerr("InvalidListType"),
-            };
-            RetWhole(Value::from_kind_and_type(
-                ValueKind::EmptyListLit(arg),
-                t.clone(),
-            ))
-        }
-        ExprKind::NEListLit(xs) => {
-            let mut iter = xs.iter().enumerate();
-            let (_, x) = iter.next().unwrap();
-            for (_, y) in iter {
-                if x.get_type()? != y.get_type()? {
-                    return mkerr("InvalidListElement");
-                }
-            }
-            let t = x.get_type()?;
-            if t.get_type()?.as_const() != Some(Const::Type) {
-                return mkerr("InvalidListType");
-            }
-
-            RetTypeOnly(Value::from_builtin(syntax::Builtin::List).app(t))
-        }
-        ExprKind::SomeLit(x) => {
-            let t = x.get_type()?;
-            if t.get_type()?.as_const() != Some(Const::Type) {
-                return mkerr("InvalidOptionalType");
-            }
-
-            RetTypeOnly(Value::from_builtin(syntax::Builtin::Optional).app(t))
-        }
-        ExprKind::RecordType(kts) => RetWhole(tck_record_type(
-            kts.iter().map(|(x, t)| Ok((x.clone(), t.clone()))),
-        )?),
-        ExprKind::UnionType(kts) => RetWhole(tck_union_type(
-            kts.iter().map(|(x, t)| Ok((x.clone(), t.clone()))),
-        )?),
-        ExprKind::RecordLit(kvs) => RetTypeOnly(tck_record_type(
-            kvs.iter().map(|(x, v)| Ok((x.clone(), v.get_type()?))),
-        )?),
-        ExprKind::Field(r, x) => {
-            match &*r.get_type()?.as_whnf() {
-                ValueKind::RecordType(kts) => match kts.get(&x) {
-                    Some(tth) => RetTypeOnly(tth.clone()),
-                    None => return mkerr("MissingRecordField"),
-                },
-                // TODO: branch here only when r.get_type() is a Const
-                _ => {
-                    match &*r.as_whnf() {
-                        ValueKind::UnionType(kts) => match kts.get(&x) {
-                            // Constructor has type T -> < x: T, ... >
-                            Some(Some(t)) => RetTypeOnly(tck_pi_type(
-                                ctx.new_binder(x),
-                                t.clone(),
-                                r.under_binder(),
-                            )?),
-                            Some(None) => RetTypeOnly(r.clone()),
-                            None => return mkerr("MissingUnionField"),
-                        },
-                        _ => return mkerr("NotARecord"),
-                    }
-                } // _ => mkerr("NotARecord"),
-            }
-        }
-        ExprKind::Const(c) => RetWhole(const_to_value(*c)),
-        ExprKind::Builtin(b) => RetWhole(builtin_to_value(*b)),
-        ExprKind::BoolLit(_) => RetTypeOnly(builtin_to_value(Bool)),
-        ExprKind::NaturalLit(_) => RetTypeOnly(builtin_to_value(Natural)),
-        ExprKind::IntegerLit(_) => RetTypeOnly(builtin_to_value(Integer)),
-        ExprKind::DoubleLit(_) => RetTypeOnly(builtin_to_value(Double)),
-        ExprKind::TextLit(interpolated) => {
-            let text_type = builtin_to_value(Text);
-            for contents in interpolated.iter() {
-                use InterpolatedTextContents::Expr;
-                if let Expr(x) = contents {
-                    if x.get_type()? != text_type {
-                        return mkerr("InvalidTextInterpolation");
-                    }
-                }
-            }
-            RetTypeOnly(text_type)
-        }
-        ExprKind::BinOp(RightBiasedRecordMerge, l, r) => {
-            let l_type = l.get_type()?;
-            let r_type = r.get_type()?;
-
-            // Extract the LHS record type
-            let l_type_borrow = l_type.as_whnf();
-            let kts_x = match &*l_type_borrow {
-                ValueKind::RecordType(kts) => kts,
-                _ => return mkerr("MustCombineRecord"),
-            };
-
-            // Extract the RHS record type
-            let r_type_borrow = r_type.as_whnf();
-            let kts_y = match &*r_type_borrow {
-                ValueKind::RecordType(kts) => kts,
-                _ => return mkerr("MustCombineRecord"),
-            };
-
-            // Union the two records, prefering
-            // the values found in the RHS.
-            let kts = merge_maps::<_, _, _, !>(kts_x, kts_y, |_, _, r_t| {
-                Ok(r_t.clone())
-            })?;
-
-            // Construct the final record type from the union
-            RetTypeOnly(tck_record_type(
-                kts.into_iter().map(|(x, v)| Ok((x.clone(), v))),
-            )?)
-        }
-        ExprKind::BinOp(RecursiveRecordMerge, l, r) => {
-            RetTypeOnly(type_last_layer(
-                ctx,
-                ExprKind::BinOp(
-                    RecursiveRecordTypeMerge,
-                    l.get_type()?,
-                    r.get_type()?,
-                ),
-                Span::Artificial,
-            )?)
-        }
-        ExprKind::BinOp(RecursiveRecordTypeMerge, l, r) => {
-            // Extract the LHS record type
-            let borrow_l = l.as_whnf();
-            let kts_x = match &*borrow_l {
-                ValueKind::RecordType(kts) => kts,
-                _ => return mkerr("RecordTypeMergeRequiresRecordType"),
-            };
-
-            // Extract the RHS record type
-            let borrow_r = r.as_whnf();
-            let kts_y = match &*borrow_r {
-                ValueKind::RecordType(kts) => kts,
-                _ => return mkerr("RecordTypeMergeRequiresRecordType"),
-            };
-
-            // Ensure that the records combine without a type error
-            let kts = merge_maps(
-                kts_x,
-                kts_y,
-                // If the Label exists for both records, then we hit the recursive case.
-                |_, l: &Value, r: &Value| {
-                    type_last_layer(
-                        ctx,
-                        ExprKind::BinOp(
-                            RecursiveRecordTypeMerge,
-                            l.clone(),
-                            r.clone(),
-                        ),
-                        Span::Artificial,
-                    )
-                },
-            )?;
-
-            RetWhole(tck_record_type(kts.into_iter().map(Ok))?)
-        }
-        ExprKind::BinOp(ListAppend, l, r) => {
-            match &*l.get_type()?.as_whnf() {
-                ValueKind::AppliedBuiltin(List, _, _, _) => {}
-                _ => return mkerr("BinOpTypeMismatch"),
-            }
-
-            if l.get_type()? != r.get_type()? {
-                return mkerr("BinOpTypeMismatch");
-            }
-
-            RetTypeOnly(l.get_type()?)
-        }
-        ExprKind::BinOp(Equivalence, l, r) => {
-            if l.get_type()?.get_type()?.as_const() != Some(Const::Type) {
-                return mkerr("EquivalenceArgumentMustBeTerm");
-            }
-            if r.get_type()?.get_type()?.as_const() != Some(Const::Type) {
-                return mkerr("EquivalenceArgumentMustBeTerm");
-            }
-
-            if l.get_type()? != r.get_type()? {
-                return mkerr("EquivalenceTypeMismatch");
-            }
-
-            RetWhole(Value::from_kind_and_type(
-                ValueKind::Equivalence(l.clone(), r.clone()),
-                Value::from_const(Type),
-            ))
-        }
-        ExprKind::BinOp(o, l, r) => {
-            let t = builtin_to_value(match o {
-                BoolAnd => Bool,
-                BoolOr => Bool,
-                BoolEQ => Bool,
-                BoolNE => Bool,
-                NaturalPlus => Natural,
-                NaturalTimes => Natural,
-                TextAppend => Text,
-                ListAppend => unreachable!(),
-                RightBiasedRecordMerge => unreachable!(),
-                RecursiveRecordMerge => unreachable!(),
-                RecursiveRecordTypeMerge => unreachable!(),
-                ImportAlt => unreachable!("There should remain no import alternatives in a resolved expression"),
-                Equivalence => unreachable!(),
-            });
-
-            if l.get_type()? != t {
-                return mkerr("BinOpTypeMismatch");
-            }
-
-            if r.get_type()? != t {
-                return mkerr("BinOpTypeMismatch");
-            }
-
-            RetTypeOnly(t)
-        }
-        ExprKind::Merge(record, union, type_annot) => {
-            let record_type = record.get_type()?;
-            let record_borrow = record_type.as_whnf();
-            let handlers = match &*record_borrow {
-                ValueKind::RecordType(kts) => kts,
-                _ => return mkerr("Merge1ArgMustBeRecord"),
-            };
-
-            let union_type = union.get_type()?;
-            let union_borrow = union_type.as_whnf();
-            let variants = match &*union_borrow {
-                ValueKind::UnionType(kts) => Cow::Borrowed(kts),
-                ValueKind::AppliedBuiltin(
-                    syntax::Builtin::Optional,
-                    args,
-                    _,
-                    _,
-                ) if args.len() == 1 => {
-                    let ty = &args[0];
-                    let mut kts = HashMap::new();
-                    kts.insert("None".into(), None);
-                    kts.insert("Some".into(), Some(ty.clone()));
-                    Cow::Owned(kts)
-                }
-                _ => return mkerr("Merge2ArgMustBeUnionOrOptional"),
-            };
-
-            let mut inferred_type = None;
-            for (x, handler_type) in handlers {
-                let handler_return_type =
-                    match variants.get(x) {
-                        // Union alternative with type
-                        Some(Some(variant_type)) => {
-                            let handler_type_borrow = handler_type.as_whnf();
-                            let (tx, tb) = match &*handler_type_borrow {
-                                ValueKind::Pi(_, tx, tb) => (tx, tb),
-                                _ => return mkerr("NotAFunction"),
-                            };
-
-                            if variant_type != tx {
-                                return mkerr("TypeMismatch");
-                            }
-
-                            // Extract `tb` from under the binder. Fails if the variable was used
-                            // in `tb`.
-                            match tb.over_binder() {
-                                Some(x) => x,
-                                None => return mkerr(
-                                    "MergeHandlerReturnTypeMustNotBeDependent",
-                                ),
-                            }
-                        }
-                        // Union alternative without type
-                        Some(None) => handler_type.clone(),
-                        None => return mkerr("MergeHandlerMissingVariant"),
-                    };
-                match &inferred_type {
-                    None => inferred_type = Some(handler_return_type),
-                    Some(t) => {
-                        if t != &handler_return_type {
-                            return mkerr("MergeHandlerTypeMismatch");
-                        }
-                    }
-                }
-            }
-            for x in variants.keys() {
-                if !handlers.contains_key(x) {
-                    return mkerr("MergeVariantMissingHandler");
-                }
-            }
-
-            match (inferred_type, type_annot.as_ref()) {
-                (Some(t1), Some(t2)) => {
-                    if &t1 != t2 {
-                        return mkerr("MergeAnnotMismatch");
-                    }
-                    RetTypeOnly(t1)
-                }
-                (Some(t), None) => RetTypeOnly(t),
-                (None, Some(t)) => RetTypeOnly(t.clone()),
-                (None, None) => return mkerr("MergeEmptyNeedsAnnotation"),
-            }
-        }
-        ExprKind::ToMap(_, _) => unimplemented!("toMap"),
-        ExprKind::Projection(record, labels) => {
-            let record_type = record.get_type()?;
-            let record_type_borrow = record_type.as_whnf();
-            let kts = match &*record_type_borrow {
-                ValueKind::RecordType(kts) => kts,
-                _ => return mkerr("ProjectionMustBeRecord"),
-            };
-
-            let mut new_kts = HashMap::new();
-            for l in labels {
-                match kts.get(l) {
-                    None => return mkerr("ProjectionMissingEntry"),
-                    Some(t) => {
-                        use std::collections::hash_map::Entry;
-                        match new_kts.entry(l.clone()) {
-                            Entry::Occupied(_) => {
-                                return mkerr("ProjectionDuplicateField")
-                            }
-                            Entry::Vacant(e) => e.insert(t.clone()),
-                        }
-                    }
-                };
-            }
-
-            RetTypeOnly(Value::from_kind_and_type(
-                ValueKind::RecordType(new_kts),
-                record_type.get_type()?,
-            ))
-        }
-        ExprKind::ProjectionByExpr(_, _) => {
-            unimplemented!("selection by expression")
-        }
-        ExprKind::Completion(_, _) => unimplemented!("record completion"),
-    };
-
-    Ok(match ret {
-        RetTypeOnly(typ) => Value::from_kind_and_type_and_span(
-            ValueKind::PartialExpr(e),
-            typ,
-            span,
-        ),
-        RetWhole(v) => v.with_span(span),
-    })
-}
-
-/// `type_of` is the same as `type_with` with an empty context, meaning that the
-/// expression must be closed (i.e. no free variables), otherwise type-checking
-/// will fail.
-pub(crate) fn typecheck(e: Expr<Normalized>) -> Result<Value, TypeError> {
-    type_with(&TyCtx::new(), e)
-}
-
-pub(crate) fn typecheck_with(
-    expr: Expr<Normalized>,
-    ty: Expr<Normalized>,
-) -> Result<Value, TypeError> {
-    typecheck(expr.rewrap(ExprKind::Annot(expr.clone(), ty)))
-}
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index e4108ad..abb6fa8 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -1,4 +1,3 @@
-#![allow(dead_code)]
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::var::AlphaVar;
 use crate::semantics::phase::normalize::{normalize_tyexpr_whnf, NzEnv};
@@ -58,10 +57,6 @@ impl TyExpr {
         let mut env = env.iter().collect();
         tyexpr_to_expr(self, opts, &mut env)
     }
-    // TODO: temporary hack
-    pub fn to_value(&self) -> Value {
-        todo!()
-    }
 
     pub fn normalize_whnf(&self, env: &NzEnv) -> Value {
         normalize_tyexpr_whnf(self, env)
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index abb36e1..99eb31f 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -1,12 +1,8 @@
-#![allow(dead_code)]
-#![allow(unreachable_code)]
-#![allow(unused_imports)]
 use std::borrow::Cow;
 use std::cmp::max;
 use std::collections::HashMap;
 
 use crate::error::{TypeError, TypeMessage};
-use crate::semantics::core::context::TyCtx;
 use crate::semantics::nze::{NameEnv, NzVar, QuoteEnv};
 use crate::semantics::phase::normalize::{merge_maps, NzEnv};
 use crate::semantics::phase::typecheck::{
@@ -14,12 +10,12 @@ use crate::semantics::phase::typecheck::{
 };
 use crate::semantics::phase::Normalized;
 use crate::semantics::{
-    AlphaVar, Binder, Closure, TyExpr, TyExprKind, Type, Value, ValueKind,
+    Binder, Closure, TyExpr, TyExprKind, Type, Value, ValueKind,
 };
 use crate::syntax;
 use crate::syntax::{
     BinOp, Builtin, Const, Expr, ExprKind, InterpolatedTextContents, Label,
-    Span, UnspannedExpr, V,
+    Span, V,
 };
 
 #[derive(Debug, Clone)]
@@ -111,6 +107,8 @@ fn mkerr<T>(x: impl ToString) -> Result<T, TypeError> {
     Err(TypeError::new(TypeMessage::Custom(x.to_string())))
 }
 
+/// When all sub-expressions have been typed, check the remaining toplevel
+/// layer.
 fn type_one_layer(
     env: &TyEnv,
     kind: &ExprKind<TyExpr, Normalized>,
@@ -503,20 +501,6 @@ fn type_one_layer(
                     Some(Some(variant_type)) => {
                         let handler_type_borrow = handler_type.as_whnf();
                         match &*handler_type_borrow {
-                            ValueKind::Pi(_, tx, tb) => {
-                                if variant_type != tx {
-                                    return mkerr("MergeHandlerTypeMismatch");
-                                }
-
-                                // Extract `tb` from under the binder. Fails if the variable was used
-                                // in `tb`.
-                                match tb.over_binder() {
-                                    Some(x) => x,
-                                    None => return mkerr(
-                                        "MergeHandlerReturnTypeMustNotBeDependent",
-                                    ),
-                                }
-                            }
                             ValueKind::PiClosure { closure, annot, .. } => {
                                 if variant_type != annot {
                                     // return mkerr("MergeHandlerTypeMismatch");
@@ -609,8 +593,7 @@ fn type_one_layer(
     })
 }
 
-/// Type-check an expression and return the expression alongside its type if type-checking
-/// succeeded, or an error if type-checking failed.
+/// `type_with` typechecks an expressio in the provided environment.
 pub(crate) fn type_with(
     env: &TyEnv,
     expr: &Expr<Normalized>,
@@ -689,10 +672,13 @@ pub(crate) fn type_with(
     Ok(TyExpr::new(tyekind, ty, expr.span()))
 }
 
+/// Typecheck an expression and return the expression annotated with types if type-checking
+/// succeeded, or an error if type-checking failed.
 pub(crate) fn typecheck(e: &Expr<Normalized>) -> Result<TyExpr, TypeError> {
     type_with(&TyEnv::new(), e)
 }
 
+/// Like `typecheck`, but additionally checks that the expression's type matches the provided type.
 pub(crate) fn typecheck_with(
     expr: &Expr<Normalized>,
     ty: Expr<Normalized>,
diff --git a/dhall/src/syntax/ast/expr.rs b/dhall/src/syntax/ast/expr.rs
index dbe233b..0da617b 100644
--- a/dhall/src/syntax/ast/expr.rs
+++ b/dhall/src/syntax/ast/expr.rs
@@ -330,10 +330,6 @@ impl<Label: PartialEq + Clone> V<Label> {
             V(y.clone(), *m)
         })
     }
-
-    pub(crate) fn over_binder(&self, x: &Label) -> Option<Self> {
-        self.shift(-1, &V(x.clone(), 0))
-    }
 }
 
 pub fn trivial_result<T>(x: Result<T, !>) -> T {
-- 
cgit v1.2.3


From 26d4975a4c94c2b9fd0c075ad94c2588e3cf24e8 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 29 Jan 2020 21:29:53 +0000
Subject: Use NameEnv in tyexpr_to_expr

---
 dhall/src/semantics/nze/nzexpr.rs | 31 ++++++++++++++-----------------
 dhall/src/semantics/tck/tyexpr.rs | 27 +++++++++------------------
 2 files changed, 23 insertions(+), 35 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/nze/nzexpr.rs b/dhall/src/semantics/nze/nzexpr.rs
index 043840e..7263cac 100644
--- a/dhall/src/semantics/nze/nzexpr.rs
+++ b/dhall/src/semantics/nze/nzexpr.rs
@@ -35,9 +35,6 @@ impl NameEnv {
             size: self.names.len(),
         }
     }
-    pub fn names(&self) -> &[Binder] {
-        &self.names
-    }
 
     pub fn insert(&self, x: &Binder) -> Self {
         let mut env = self.clone();
@@ -47,9 +44,9 @@ impl NameEnv {
     pub fn insert_mut(&mut self, x: &Binder) {
         self.names.push(x.clone())
     }
-    // pub fn remove_mut(&mut self) {
-    //     self.names.pop();
-    // }
+    pub fn remove_mut(&mut self) {
+        self.names.pop();
+    }
 
     pub fn unlabel_var(&self, var: &V<Binder>) -> Option<AlphaVar> {
         let V(name, idx) = var;
@@ -62,17 +59,17 @@ impl NameEnv {
             .nth(*idx)?;
         Some(AlphaVar::new(V((), idx)))
     }
-    // pub fn label_var(&self, var: &AlphaVar) -> V<Binder> {
-    //     let name = &self.names[self.names.len() - 1 - var.idx()];
-    //     let idx = self
-    //         .names
-    //         .iter()
-    //         .rev()
-    //         .take(var.idx())
-    //         .filter(|n| *n == name)
-    //         .count();
-    //     V(name.clone(), idx)
-    // }
+    pub fn label_var(&self, var: &AlphaVar) -> V<Binder> {
+        let name = &self.names[self.names.len() - 1 - var.idx()];
+        let idx = self
+            .names
+            .iter()
+            .rev()
+            .take(var.idx())
+            .filter(|n| *n == name)
+            .count();
+        V(name.clone(), idx)
+    }
 }
 
 // TODO: rename to VarEnv
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index abb6fa8..b64c519 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -1,12 +1,13 @@
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::var::AlphaVar;
+use crate::semantics::nze::nzexpr::NameEnv;
 use crate::semantics::phase::normalize::{normalize_tyexpr_whnf, NzEnv};
 use crate::semantics::phase::typecheck::rc;
 use crate::semantics::phase::Normalized;
 use crate::semantics::phase::{NormalizedExpr, ToExprOptions};
 use crate::semantics::tck::typecheck::TyEnv;
 use crate::semantics::Value;
-use crate::syntax::{ExprKind, Label, Span, V};
+use crate::syntax::{ExprKind, Span, V};
 
 pub(crate) type Type = Value;
 
@@ -46,15 +47,14 @@ impl TyExpr {
 
     /// Converts a value back to the corresponding AST expression.
     pub fn to_expr(&self, opts: ToExprOptions) -> NormalizedExpr {
-        tyexpr_to_expr(self, opts, &mut Vec::new())
+        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 env = env.as_nameenv().names();
-        let mut env = env.iter().collect();
+        let mut env = env.as_nameenv().clone();
         tyexpr_to_expr(self, opts, &mut env)
     }
 
@@ -77,30 +77,21 @@ impl TyExpr {
 fn tyexpr_to_expr<'a>(
     tyexpr: &'a TyExpr,
     opts: ToExprOptions,
-    ctx: &mut Vec<&'a Label>,
+    env: &mut NameEnv,
 ) -> NormalizedExpr {
     rc(match tyexpr.kind() {
         TyExprKind::Var(v) if opts.alpha => {
             ExprKind::Var(V("_".into(), v.idx()))
         }
-        TyExprKind::Var(v) => {
-            let name = ctx[ctx.len() - 1 - v.idx()];
-            let idx = ctx
-                .iter()
-                .rev()
-                .take(v.idx())
-                .filter(|l| **l == name)
-                .count();
-            ExprKind::Var(V(name.clone(), 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 {
-                    ctx.push(l);
+                    env.insert_mut(l);
                 }
-                let e = tyexpr_to_expr(tye, opts, ctx);
+                let e = tyexpr_to_expr(tye, opts, env);
                 if let Some(_) = l {
-                    ctx.pop();
+                    env.remove_mut();
                 }
                 e
             });
-- 
cgit v1.2.3


From 22bec94618454f57773716870f5624579ab712ce Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 29 Jan 2020 21:31:53 +0000
Subject: s/QuoteEnv/VarEnv/

---
 dhall/src/semantics/core/value.rs    | 36 ++++++++++++++++++------------------
 dhall/src/semantics/nze/nzexpr.rs    | 13 ++++++-------
 dhall/src/semantics/tck/typecheck.rs | 34 ++++++++++++++++------------------
 3 files changed, 40 insertions(+), 43 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 30c4116..df1382b 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -4,7 +4,7 @@ use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::var::{AlphaVar, Binder};
-use crate::semantics::nze::{NzVar, QuoteEnv};
+use crate::semantics::nze::{NzVar, VarEnv};
 use crate::semantics::phase::normalize::{apply_any, normalize_whnf, NzEnv};
 use crate::semantics::phase::typecheck::{
     builtin_to_value, builtin_to_value_env, const_to_value,
@@ -277,21 +277,21 @@ impl Value {
         }
     }
 
-    pub fn to_tyexpr(&self, qenv: QuoteEnv) -> TyExpr {
+    pub fn to_tyexpr(&self, venv: VarEnv) -> TyExpr {
         let tye = match &*self.as_kind() {
             // ValueKind::Var(v, _w) => TyExprKind::Var(*v),
             // TODO: Only works when we don't normalize under lambdas
-            ValueKind::Var(_v, w) => TyExprKind::Var(qenv.lookup(w)),
+            ValueKind::Var(_v, w) => TyExprKind::Var(venv.lookup(w)),
             ValueKind::LamClosure {
                 binder,
                 annot,
                 closure,
             } => TyExprKind::Expr(ExprKind::Lam(
                 binder.to_label(),
-                annot.to_tyexpr(qenv),
+                annot.to_tyexpr(venv),
                 closure
-                    .apply_var(NzVar::new(qenv.size()))
-                    .to_tyexpr(qenv.insert()),
+                    .apply_var(NzVar::new(venv.size()))
+                    .to_tyexpr(venv.insert()),
             )),
             ValueKind::PiClosure {
                 binder,
@@ -299,10 +299,10 @@ impl Value {
                 closure,
             } => TyExprKind::Expr(ExprKind::Pi(
                 binder.to_label(),
-                annot.to_tyexpr(qenv),
+                annot.to_tyexpr(venv),
                 closure
-                    .apply_var(NzVar::new(qenv.size()))
-                    .to_tyexpr(qenv.insert()),
+                    .apply_var(NzVar::new(venv.size()))
+                    .to_tyexpr(venv.insert()),
             )),
             ValueKind::AppliedBuiltin(b, args, types, _) => {
                 TyExprKind::Expr(args.into_iter().zip(types.into_iter()).fold(
@@ -314,7 +314,7 @@ impl Value {
                                 Some(ty.clone()),
                                 Span::Artificial,
                             ),
-                            v.to_tyexpr(qenv),
+                            v.to_tyexpr(venv),
                         )
                     },
                 ))
@@ -327,7 +327,7 @@ impl Value {
                                 .map(|(k, v)| {
                                     (
                                         k.clone(),
-                                        v.as_ref().map(|v| v.to_tyexpr(qenv)),
+                                        v.as_ref().map(|v| v.to_tyexpr(venv)),
                                     )
                                 })
                                 .collect(),
@@ -349,7 +349,7 @@ impl Value {
                                             (
                                                 k.clone(),
                                                 v.as_ref()
-                                                    .map(|v| v.to_tyexpr(qenv)),
+                                                    .map(|v| v.to_tyexpr(venv)),
                                             )
                                         })
                                         .collect(),
@@ -362,14 +362,14 @@ impl Value {
                         Some(ctort.clone()),
                         Span::Artificial,
                     ),
-                    v.to_tyexpr(qenv),
+                    v.to_tyexpr(venv),
                 ))
             }
             self_kind => {
                 let self_kind = self_kind
                     .map_ref_with_special_handling_of_binders(
-                        |v| v.to_tyexpr(qenv),
-                        |_, _, v| v.to_tyexpr(qenv.insert()),
+                        |v| v.to_tyexpr(venv),
+                        |_, _, v| v.to_tyexpr(venv.insert()),
                     );
                 let expr = match self_kind {
                     ValueKind::Var(..)
@@ -384,14 +384,14 @@ impl Value {
                     ValueKind::IntegerLit(n) => ExprKind::IntegerLit(n),
                     ValueKind::DoubleLit(n) => ExprKind::DoubleLit(n),
                     ValueKind::EmptyOptionalLit(n) => ExprKind::App(
-                        builtin_to_value(Builtin::OptionalNone).to_tyexpr(qenv),
+                        builtin_to_value(Builtin::OptionalNone).to_tyexpr(venv),
                         n,
                     ),
                     ValueKind::NEOptionalLit(n) => ExprKind::SomeLit(n),
                     ValueKind::EmptyListLit(n) => {
                         ExprKind::EmptyListLit(TyExpr::new(
                             TyExprKind::Expr(ExprKind::App(
-                                builtin_to_value(Builtin::List).to_tyexpr(qenv),
+                                builtin_to_value(Builtin::List).to_tyexpr(venv),
                                 n,
                             )),
                             Some(const_to_value(Const::Type)),
@@ -425,7 +425,7 @@ impl Value {
         TyExpr::new(tye, self_ty, self_span)
     }
     pub fn to_tyexpr_noenv(&self) -> TyExpr {
-        self.to_tyexpr(QuoteEnv::new())
+        self.to_tyexpr(VarEnv::new())
     }
 }
 
diff --git a/dhall/src/semantics/nze/nzexpr.rs b/dhall/src/semantics/nze/nzexpr.rs
index 7263cac..87d0269 100644
--- a/dhall/src/semantics/nze/nzexpr.rs
+++ b/dhall/src/semantics/nze/nzexpr.rs
@@ -9,7 +9,7 @@ pub(crate) struct NameEnv {
 }
 
 #[derive(Debug, Clone, Copy)]
-pub(crate) struct QuoteEnv {
+pub(crate) struct VarEnv {
     size: usize,
 }
 
@@ -30,8 +30,8 @@ impl NameEnv {
             names: names.collect(),
         }
     }
-    pub fn as_quoteenv(&self) -> QuoteEnv {
-        QuoteEnv {
+    pub fn as_varenv(&self) -> VarEnv {
+        VarEnv {
             size: self.names.len(),
         }
     }
@@ -72,16 +72,15 @@ impl NameEnv {
     }
 }
 
-// TODO: rename to VarEnv
-impl QuoteEnv {
+impl VarEnv {
     pub fn new() -> Self {
-        QuoteEnv { size: 0 }
+        VarEnv { size: 0 }
     }
     pub fn size(&self) -> usize {
         self.size
     }
     pub fn insert(&self) -> Self {
-        QuoteEnv {
+        VarEnv {
             size: self.size + 1,
         }
     }
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index 99eb31f..7a225f7 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -3,7 +3,7 @@ use std::cmp::max;
 use std::collections::HashMap;
 
 use crate::error::{TypeError, TypeMessage};
-use crate::semantics::nze::{NameEnv, NzVar, QuoteEnv};
+use crate::semantics::nze::{NameEnv, NzVar, VarEnv};
 use crate::semantics::phase::normalize::{merge_maps, NzEnv};
 use crate::semantics::phase::typecheck::{
     builtin_to_value, const_to_value, type_of_builtin,
@@ -39,8 +39,8 @@ impl TyEnv {
             items: items.clone(),
         }
     }
-    pub fn as_quoteenv(&self) -> QuoteEnv {
-        self.names.as_quoteenv()
+    pub fn as_varenv(&self) -> VarEnv {
+        self.names.as_varenv()
     }
     pub fn as_nzenv(&self) -> &NzEnv {
         &self.items
@@ -194,7 +194,7 @@ fn type_one_layer(
 
             let ty = type_of_recordtype(
                 kts.iter()
-                    .map(|(_, t)| Cow::Owned(t.to_tyexpr(env.as_quoteenv()))),
+                    .map(|(_, t)| Cow::Owned(t.to_tyexpr(env.as_varenv()))),
             )?;
             Value::from_kind_and_type(ValueKind::RecordType(kts), ty)
         }
@@ -282,13 +282,13 @@ fn type_one_layer(
                 return mkerr(format!(
                     "annot mismatch: ({} : {}) : {}",
                     x.to_expr_tyenv(env),
-                    x_ty.to_tyexpr(env.as_quoteenv()).to_expr_tyenv(env),
-                    t.to_tyexpr(env.as_quoteenv()).to_expr_tyenv(env)
+                    x_ty.to_tyexpr(env.as_varenv()).to_expr_tyenv(env),
+                    t.to_tyexpr(env.as_varenv()).to_expr_tyenv(env)
                 ));
                 // return mkerr(format!(
                 //     "annot mismatch: {} != {}",
-                //     x_ty.to_tyexpr(env.as_quoteenv()).to_expr_tyenv(env),
-                //     t.to_tyexpr(env.as_quoteenv()).to_expr_tyenv(env)
+                //     x_ty.to_tyexpr(env.as_varenv()).to_expr_tyenv(env),
+                //     t.to_tyexpr(env.as_varenv()).to_expr_tyenv(env)
                 // ));
                 // return mkerr(format!("annot mismatch: {:#?} : {:#?}", x, t,));
             }
@@ -314,11 +314,9 @@ fn type_one_layer(
                             "function annot mismatch: ({} : {}) : {}",
                             arg.to_expr_tyenv(env),
                             arg.get_type()?
-                                .to_tyexpr(env.as_quoteenv())
-                                .to_expr_tyenv(env),
-                            annot
-                                .to_tyexpr(env.as_quoteenv())
+                                .to_tyexpr(env.as_varenv())
                                 .to_expr_tyenv(env),
+                            annot.to_tyexpr(env.as_varenv()).to_expr_tyenv(env),
                         ));
                     }
 
@@ -373,15 +371,15 @@ fn type_one_layer(
             // Construct the final record type
             let ty = type_of_recordtype(
                 kts.iter()
-                    .map(|(_, t)| Cow::Owned(t.to_tyexpr(env.as_quoteenv()))),
+                    .map(|(_, t)| Cow::Owned(t.to_tyexpr(env.as_varenv()))),
             )?;
             Value::from_kind_and_type(ValueKind::RecordType(kts), ty)
         }
         ExprKind::BinOp(BinOp::RecursiveRecordMerge, x, y) => {
             let ekind = ExprKind::BinOp(
                 BinOp::RecursiveRecordTypeMerge,
-                x.get_type()?.to_tyexpr(env.as_quoteenv()),
-                y.get_type()?.to_tyexpr(env.as_quoteenv()),
+                x.get_type()?.to_tyexpr(env.as_varenv()),
+                y.get_type()?.to_tyexpr(env.as_varenv()),
             );
             let ty = type_one_layer(env, &ekind)?;
             TyExpr::new(TyExprKind::Expr(ekind), Some(ty), Span::Artificial)
@@ -406,8 +404,8 @@ fn type_one_layer(
                         env,
                         &ExprKind::BinOp(
                             BinOp::RecursiveRecordTypeMerge,
-                            tx.to_tyexpr(env.as_quoteenv()),
-                            ty.to_tyexpr(env.as_quoteenv()),
+                            tx.to_tyexpr(env.as_varenv()),
+                            ty.to_tyexpr(env.as_varenv()),
                         ),
                     )?;
                 }
@@ -613,7 +611,7 @@ pub(crate) fn type_with(
                 TyExprKind::Expr(ExprKind::Pi(
                     binder.clone(),
                     annot.clone(),
-                    body_ty.to_tyexpr(body_env.as_quoteenv()),
+                    body_ty.to_tyexpr(body_env.as_varenv()),
                 )),
                 Some(type_of_function(annot.get_type()?, body_ty.get_type()?)?),
                 Span::Artificial,
-- 
cgit v1.2.3


From 280b3174476ef8fe5a98f3614f4fe253fa243d8c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 29 Jan 2020 21:35:28 +0000
Subject: Finally get rid of all of the shift/subst_shift !

---
 dhall/src/semantics/core/value.rs      | 72 ----------------------------------
 dhall/src/semantics/core/var.rs        | 10 -----
 dhall/src/semantics/nze/nzexpr.rs      |  3 --
 dhall/src/semantics/phase/normalize.rs |  8 ++--
 dhall/src/syntax/ast/expr.rs           | 22 -----------
 5 files changed, 3 insertions(+), 112 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index df1382b..90b30b4 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -256,27 +256,6 @@ impl Value {
             .expect("Internal type error: value is `Sort` but shouldn't be")
     }
 
-    pub(crate) fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(self.as_internal().shift(delta, var)?.into_value())
-    }
-    pub(crate) fn under_binder(&self) -> Self {
-        // Can't fail since delta is positive
-        self.shift(1, &AlphaVar::default()).unwrap()
-    }
-    pub(crate) fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
-        match &*self.as_kind() {
-            // If the var matches, we can just reuse the provided value instead of copying it.
-            // We also check that the types match, if in debug mode.
-            ValueKind::Var(v, _) if v == var => {
-                if let Ok(self_ty) = self.get_type() {
-                    val.check_type(&self_ty.subst_shift(var, val));
-                }
-                val.clone()
-            }
-            _ => self.as_internal().subst_shift(var, val).into_value(),
-        }
-    }
-
     pub fn to_tyexpr(&self, venv: VarEnv) -> TyExpr {
         let tye = match &*self.as_kind() {
             // ValueKind::Var(v, _w) => TyExprKind::Var(*v),
@@ -487,27 +466,6 @@ impl ValueInternal {
             None => Err(TypeError::new(TypeMessage::Sort)),
         }
     }
-
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(ValueInternal {
-            form: self.form,
-            kind: self.kind.shift(delta, var)?,
-            ty: match &self.ty {
-                None => None,
-                Some(ty) => Some(ty.shift(delta, var)?),
-            },
-            span: self.span.clone(),
-        })
-    }
-    fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
-        ValueInternal {
-            // The resulting value may not stay in wnhf after substitution
-            form: Unevaled,
-            kind: self.kind.subst_shift(var, val),
-            ty: self.ty.as_ref().map(|x| x.subst_shift(var, val)),
-            span: self.span.clone(),
-        }
-    }
 }
 
 impl ValueKind<Value> {
@@ -588,36 +546,6 @@ impl ValueKind<Value> {
     pub(crate) fn from_builtin_env(b: Builtin, env: NzEnv) -> ValueKind<Value> {
         ValueKind::AppliedBuiltin(b, vec![], vec![], env)
     }
-
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(match self {
-            ValueKind::Var(v, w) if var.idx() <= v.idx() => {
-                ValueKind::Var(v.shift(delta, var)?, *w)
-            }
-            ValueKind::Var(v, w) => {
-                ValueKind::Var(v.shift(delta, var)?, w.shift(delta))
-            }
-            // ValueKind::Var(v, w) => ValueKind::Var(v.shift(delta, var)?, *w),
-            _ => self.traverse_ref_with_special_handling_of_binders(
-                |x| Ok(x.shift(delta, var)?),
-                |_, _, x| Ok(x.shift(delta, &var.under_binder())?),
-            )?,
-        })
-    }
-    fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
-        match self {
-            ValueKind::Var(v, _) if v == var => val.to_whnf_ignore_type(),
-            ValueKind::Var(v, w) => {
-                ValueKind::Var(v.shift(-1, var).unwrap(), *w)
-            }
-            _ => self.map_ref_with_special_handling_of_binders(
-                |x| x.subst_shift(var, val),
-                |_, _, x| {
-                    x.subst_shift(&var.under_binder(), &val.under_binder())
-                },
-            ),
-        }
-    }
 }
 
 impl<V> ValueKind<V> {
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index cf45d5e..3458489 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -29,16 +29,6 @@ impl AlphaVar {
     pub(crate) fn idx(&self) -> usize {
         self.alpha.idx()
     }
-
-    pub(crate) fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(AlphaVar {
-            alpha: self.alpha.shift(delta, &var.alpha)?,
-        })
-    }
-    pub(crate) fn under_binder(&self) -> Self {
-        // Can't fail since delta is positive
-        self.shift(1, &AlphaVar::default()).unwrap()
-    }
 }
 
 impl Binder {
diff --git a/dhall/src/semantics/nze/nzexpr.rs b/dhall/src/semantics/nze/nzexpr.rs
index 87d0269..c065a5b 100644
--- a/dhall/src/semantics/nze/nzexpr.rs
+++ b/dhall/src/semantics/nze/nzexpr.rs
@@ -104,9 +104,6 @@ impl NzVar {
         let id = FRESH_VAR_COUNTER.fetch_add(1, Ordering::SeqCst);
         NzVar::Fresh(id)
     }
-    pub fn shift(&self, delta: isize) -> Self {
-        NzVar::new((self.idx() as isize + delta) as usize)
-    }
     // Panics on a fresh variable.
     pub fn idx(&self) -> usize {
         match self {
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index d40456b..fa80b6e 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -638,15 +638,13 @@ pub(crate) fn normalize_one_layer(
         ),
         // Those cases have already been completely handled in the typechecking phase (using
         // `RetWhole`), so they won't appear here.
-        ExprKind::Lam(_, _, _)
-        | ExprKind::Pi(_, _, _)
+        ExprKind::Lam(..)
+        | ExprKind::Pi(..)
+        | ExprKind::Let(..)
         | ExprKind::Embed(_)
         | ExprKind::Var(_) => {
             unreachable!("This case should have been handled in typecheck")
         }
-        ExprKind::Let(_, _, val, body) => {
-            Ret::Value(body.subst_shift(&AlphaVar::default(), &val))
-        }
         ExprKind::Annot(x, _) => Ret::Value(x),
         ExprKind::Const(c) => Ret::Value(const_to_value(c)),
         ExprKind::Builtin(b) => Ret::Value(builtin_to_value_env(b, env)),
diff --git a/dhall/src/syntax/ast/expr.rs b/dhall/src/syntax/ast/expr.rs
index 0da617b..424ac34 100644
--- a/dhall/src/syntax/ast/expr.rs
+++ b/dhall/src/syntax/ast/expr.rs
@@ -320,18 +320,6 @@ impl<E> Expr<E> {
     }
 }
 
-impl<Label: PartialEq + Clone> V<Label> {
-    pub(crate) fn shift(&self, delta: isize, var: &V<Label>) -> Option<Self> {
-        let V(x, n) = var;
-        let V(y, m) = self;
-        Some(if x == y && n <= m {
-            V(y.clone(), add_ui(*m, delta)?)
-        } else {
-            V(y.clone(), *m)
-        })
-    }
-}
-
 pub fn trivial_result<T>(x: Result<T, !>) -> T {
     match x {
         Ok(x) => x,
@@ -339,16 +327,6 @@ pub fn trivial_result<T>(x: Result<T, !>) -> T {
     }
 }
 
-/// Add an isize to an usize
-/// Returns `None` on over/underflow
-fn add_ui(u: usize, i: isize) -> Option<usize> {
-    Some(if i < 0 {
-        u.checked_sub(i.checked_neg()? as usize)?
-    } else {
-        u.checked_add(i as usize)?
-    })
-}
-
 impl PartialEq for NaiveDouble {
     fn eq(&self, other: &Self) -> bool {
         self.0.to_bits() == other.0.to_bits()
-- 
cgit v1.2.3


From 489174a426e6057a68b6edd2e9b4387d09912a25 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 29 Jan 2020 21:56:52 +0000
Subject: Move envs to their own files

---
 dhall/src/semantics/core/value.rs      |   4 +-
 dhall/src/semantics/mod.rs             |   1 +
 dhall/src/semantics/nze/env.rs         |  87 +++++++++++++++++++++
 dhall/src/semantics/nze/mod.rs         |   4 +-
 dhall/src/semantics/nze/nzexpr.rs      | 116 ----------------------------
 dhall/src/semantics/phase/normalize.rs |  62 +--------------
 dhall/src/semantics/phase/typecheck.rs |   3 +-
 dhall/src/semantics/tck/env.rs         | 137 +++++++++++++++++++++++++++++++++
 dhall/src/semantics/tck/mod.rs         |   2 +
 dhall/src/semantics/tck/tyexpr.rs      |   6 +-
 dhall/src/semantics/tck/typecheck.rs   |  58 +-------------
 11 files changed, 239 insertions(+), 241 deletions(-)
 create mode 100644 dhall/src/semantics/nze/env.rs
 delete mode 100644 dhall/src/semantics/nze/nzexpr.rs
 create mode 100644 dhall/src/semantics/tck/env.rs

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 90b30b4..7334552 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -4,12 +4,12 @@ use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::var::{AlphaVar, Binder};
-use crate::semantics::nze::{NzVar, VarEnv};
-use crate::semantics::phase::normalize::{apply_any, normalize_whnf, NzEnv};
+use crate::semantics::phase::normalize::{apply_any, normalize_whnf};
 use crate::semantics::phase::typecheck::{
     builtin_to_value, builtin_to_value_env, const_to_value,
 };
 use crate::semantics::phase::{Normalized, NormalizedExpr, ToExprOptions};
+use crate::semantics::{NzEnv, NzVar, VarEnv};
 use crate::semantics::{TyExpr, TyExprKind};
 use crate::syntax::{
     BinOp, Builtin, Const, ExprKind, Integer, InterpolatedTextContents, Label,
diff --git a/dhall/src/semantics/mod.rs b/dhall/src/semantics/mod.rs
index 1304502..ce08334 100644
--- a/dhall/src/semantics/mod.rs
+++ b/dhall/src/semantics/mod.rs
@@ -3,4 +3,5 @@ pub mod nze;
 pub mod phase;
 pub mod tck;
 pub(crate) use self::core::*;
+pub(crate) use self::nze::*;
 pub(crate) use self::tck::*;
diff --git a/dhall/src/semantics/nze/env.rs b/dhall/src/semantics/nze/env.rs
new file mode 100644
index 0000000..203d99a
--- /dev/null
+++ b/dhall/src/semantics/nze/env.rs
@@ -0,0 +1,87 @@
+use crate::semantics::{AlphaVar, TyEnv, Value, ValueKind};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum NzVar {
+    /// Reverse-debruijn index: counts number of binders from the bottom of the stack.
+    Bound(usize),
+    /// Fake fresh variable generated for expression equality checking.
+    Fresh(usize),
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum NzEnvItem {
+    // Variable is bound with given type
+    Kept(Value),
+    // Variable has been replaced by corresponding value
+    Replaced(Value),
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct NzEnv {
+    items: Vec<NzEnvItem>,
+}
+
+impl NzVar {
+    pub fn new(idx: usize) -> Self {
+        NzVar::Bound(idx)
+    }
+    pub fn fresh() -> Self {
+        use std::sync::atomic::{AtomicUsize, Ordering};
+        // Global counter to ensure uniqueness of the generated id.
+        static FRESH_VAR_COUNTER: AtomicUsize = AtomicUsize::new(0);
+        let id = FRESH_VAR_COUNTER.fetch_add(1, Ordering::SeqCst);
+        NzVar::Fresh(id)
+    }
+    /// Get index of bound variable.
+    /// Panics on a fresh variable.
+    pub fn idx(&self) -> usize {
+        match self {
+            NzVar::Bound(i) => *i,
+            NzVar::Fresh(_) => panic!(
+                "Trying to use a fresh variable outside of equality checking"
+            ),
+        }
+    }
+}
+
+impl NzEnv {
+    pub fn new() -> Self {
+        NzEnv { items: Vec::new() }
+    }
+    pub fn to_alpha_tyenv(&self) -> TyEnv {
+        TyEnv::from_nzenv_alpha(self)
+    }
+
+    pub fn insert_type(&self, t: Value) -> Self {
+        let mut env = self.clone();
+        env.items.push(NzEnvItem::Kept(t));
+        env
+    }
+    pub fn insert_value(&self, e: Value) -> Self {
+        let mut env = self.clone();
+        env.items.push(NzEnvItem::Replaced(e));
+        env
+    }
+    pub fn lookup_val(&self, var: &AlphaVar) -> Value {
+        let idx = self.items.len() - 1 - var.idx();
+        match &self.items[idx] {
+            NzEnvItem::Kept(ty) => Value::from_kind_and_type_whnf(
+                ValueKind::Var(var.clone(), NzVar::new(idx)),
+                ty.clone(),
+            ),
+            NzEnvItem::Replaced(x) => x.clone(),
+        }
+    }
+
+    pub fn size(&self) -> usize {
+        self.items.len()
+    }
+}
+
+/// Ignore NzEnv when comparing; useful because we store them in `AppliedBuiltin`.
+impl std::cmp::PartialEq for NzEnv {
+    fn eq(&self, _other: &Self) -> bool {
+        true
+    }
+}
+impl std::cmp::Eq for NzEnv {}
diff --git a/dhall/src/semantics/nze/mod.rs b/dhall/src/semantics/nze/mod.rs
index 213404c..1cd2363 100644
--- a/dhall/src/semantics/nze/mod.rs
+++ b/dhall/src/semantics/nze/mod.rs
@@ -1,2 +1,2 @@
-pub mod nzexpr;
-pub(crate) use nzexpr::*;
+pub mod env;
+pub(crate) use env::*;
diff --git a/dhall/src/semantics/nze/nzexpr.rs b/dhall/src/semantics/nze/nzexpr.rs
deleted file mode 100644
index c065a5b..0000000
--- a/dhall/src/semantics/nze/nzexpr.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-use crate::semantics::core::var::AlphaVar;
-use crate::syntax::{Label, V};
-
-pub(crate) type Binder = Label;
-
-#[derive(Debug, Clone)]
-pub(crate) struct NameEnv {
-    names: Vec<Binder>,
-}
-
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct VarEnv {
-    size: usize,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum NzVar {
-    /// Reverse-debruijn index: counts number of binders from the bottom of the stack.
-    Bound(usize),
-    /// Fake fresh variable generated for expression equality checking.
-    Fresh(usize),
-}
-
-impl NameEnv {
-    pub fn new() -> Self {
-        NameEnv { names: Vec::new() }
-    }
-    pub fn from_binders(names: impl Iterator<Item = Binder>) -> Self {
-        NameEnv {
-            names: names.collect(),
-        }
-    }
-    pub fn as_varenv(&self) -> VarEnv {
-        VarEnv {
-            size: self.names.len(),
-        }
-    }
-
-    pub fn insert(&self, x: &Binder) -> Self {
-        let mut env = self.clone();
-        env.insert_mut(x);
-        env
-    }
-    pub fn insert_mut(&mut self, x: &Binder) {
-        self.names.push(x.clone())
-    }
-    pub fn remove_mut(&mut self) {
-        self.names.pop();
-    }
-
-    pub fn unlabel_var(&self, var: &V<Binder>) -> Option<AlphaVar> {
-        let V(name, idx) = var;
-        let (idx, _) = self
-            .names
-            .iter()
-            .rev()
-            .enumerate()
-            .filter(|(_, n)| *n == name)
-            .nth(*idx)?;
-        Some(AlphaVar::new(V((), idx)))
-    }
-    pub fn label_var(&self, var: &AlphaVar) -> V<Binder> {
-        let name = &self.names[self.names.len() - 1 - var.idx()];
-        let idx = self
-            .names
-            .iter()
-            .rev()
-            .take(var.idx())
-            .filter(|n| *n == name)
-            .count();
-        V(name.clone(), idx)
-    }
-}
-
-impl VarEnv {
-    pub fn new() -> Self {
-        VarEnv { size: 0 }
-    }
-    pub fn size(&self) -> usize {
-        self.size
-    }
-    pub fn insert(&self) -> Self {
-        VarEnv {
-            size: self.size + 1,
-        }
-    }
-    pub fn lookup(&self, var: &NzVar) -> AlphaVar {
-        self.lookup_fallible(var).unwrap()
-    }
-    pub fn lookup_fallible(&self, var: &NzVar) -> Option<AlphaVar> {
-        let idx = self.size.checked_sub(var.idx() + 1)?;
-        Some(AlphaVar::new(V((), idx)))
-    }
-}
-
-impl NzVar {
-    pub fn new(idx: usize) -> Self {
-        NzVar::Bound(idx)
-    }
-    pub fn fresh() -> Self {
-        use std::sync::atomic::{AtomicUsize, Ordering};
-        // Global counter to ensure uniqueness of the generated id.
-        static FRESH_VAR_COUNTER: AtomicUsize = AtomicUsize::new(0);
-        let id = FRESH_VAR_COUNTER.fetch_add(1, Ordering::SeqCst);
-        NzVar::Fresh(id)
-    }
-    // Panics on a fresh variable.
-    pub fn idx(&self) -> usize {
-        match self {
-            NzVar::Bound(i) => *i,
-            NzVar::Fresh(_) => panic!(
-                "Trying to use a fresh variable outside of equality checking"
-            ),
-        }
-    }
-}
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index fa80b6e..ce37993 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -1,16 +1,13 @@
 use std::collections::HashMap;
 use std::convert::TryInto;
 
-use crate::semantics::nze::NzVar;
 use crate::semantics::phase::typecheck::{
     builtin_to_value_env, const_to_value, rc,
 };
 use crate::semantics::phase::Normalized;
 use crate::semantics::tck::typecheck::type_with;
-use crate::semantics::tck::typecheck::TyEnv;
-use crate::semantics::{
-    AlphaVar, Binder, Closure, TyExpr, TyExprKind, Value, ValueKind,
-};
+use crate::semantics::NzEnv;
+use crate::semantics::{Binder, Closure, TyExpr, TyExprKind, Value, ValueKind};
 use crate::syntax;
 use crate::syntax::Const::Type;
 use crate::syntax::{
@@ -838,53 +835,6 @@ pub(crate) fn normalize_whnf(
     }
 }
 
-#[derive(Debug, Clone)]
-pub(crate) enum NzEnvItem {
-    // Variable is bound with given type
-    Kept(Value),
-    // Variable has been replaced by corresponding value
-    Replaced(Value),
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct NzEnv {
-    items: Vec<NzEnvItem>,
-}
-
-impl NzEnv {
-    pub fn new() -> Self {
-        NzEnv { items: Vec::new() }
-    }
-    pub fn to_alpha_tyenv(&self) -> TyEnv {
-        TyEnv::from_nzenv_alpha(self)
-    }
-
-    pub fn insert_type(&self, t: Value) -> Self {
-        let mut env = self.clone();
-        env.items.push(NzEnvItem::Kept(t));
-        env
-    }
-    pub fn insert_value(&self, e: Value) -> Self {
-        let mut env = self.clone();
-        env.items.push(NzEnvItem::Replaced(e));
-        env
-    }
-    pub fn lookup_val(&self, var: &AlphaVar) -> Value {
-        let idx = self.items.len() - 1 - var.idx();
-        match &self.items[idx] {
-            NzEnvItem::Kept(ty) => Value::from_kind_and_type_whnf(
-                ValueKind::Var(var.clone(), NzVar::new(idx)),
-                ty.clone(),
-            ),
-            NzEnvItem::Replaced(x) => x.clone(),
-        }
-    }
-
-    pub fn size(&self) -> usize {
-        self.items.len()
-    }
-}
-
 /// Normalize a TyExpr into WHNF
 pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> Value {
     let ty = match tye.get_type() {
@@ -924,11 +874,3 @@ pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> Value {
     // dbg!(tye.kind(), env, &kind);
     Value::from_kind_and_type_whnf(kind, ty)
 }
-
-/// Ignore NzEnv when comparing
-impl std::cmp::PartialEq for NzEnv {
-    fn eq(&self, _other: &Self) -> bool {
-        true
-    }
-}
-impl std::cmp::Eq for NzEnv {}
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index 4392365..2e22ad2 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -1,5 +1,4 @@
-use crate::semantics::phase::normalize::NzEnv;
-use crate::semantics::{Value, ValueKind};
+use crate::semantics::{NzEnv, Value, ValueKind};
 use crate::syntax;
 use crate::syntax::{
     Builtin, Const, Expr, ExprKind, Label, Span, UnspannedExpr,
diff --git a/dhall/src/semantics/tck/env.rs b/dhall/src/semantics/tck/env.rs
new file mode 100644
index 0000000..32c2f21
--- /dev/null
+++ b/dhall/src/semantics/tck/env.rs
@@ -0,0 +1,137 @@
+use crate::semantics::{AlphaVar, NzEnv, NzVar, TyExprKind, Type, Value};
+use crate::syntax::{Label, V};
+
+/// Environment for indexing variables.
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct VarEnv {
+    size: usize,
+}
+
+/// Environment for resolving names.
+#[derive(Debug, Clone)]
+pub(crate) struct NameEnv {
+    names: Vec<Label>,
+}
+
+/// Environment for typing expressions.
+#[derive(Debug, Clone)]
+pub(crate) struct TyEnv {
+    names: NameEnv,
+    items: NzEnv,
+}
+
+impl VarEnv {
+    pub fn new() -> Self {
+        VarEnv { size: 0 }
+    }
+    pub fn size(&self) -> usize {
+        self.size
+    }
+    pub fn insert(&self) -> Self {
+        VarEnv {
+            size: self.size + 1,
+        }
+    }
+    pub fn lookup(&self, var: &NzVar) -> AlphaVar {
+        self.lookup_fallible(var).unwrap()
+    }
+    pub fn lookup_fallible(&self, var: &NzVar) -> Option<AlphaVar> {
+        let idx = self.size.checked_sub(var.idx() + 1)?;
+        Some(AlphaVar::new(V((), idx)))
+    }
+}
+
+impl NameEnv {
+    pub fn new() -> Self {
+        NameEnv { names: Vec::new() }
+    }
+    pub fn from_binders(names: impl Iterator<Item = Label>) -> Self {
+        NameEnv {
+            names: names.collect(),
+        }
+    }
+    pub fn as_varenv(&self) -> VarEnv {
+        VarEnv {
+            size: self.names.len(),
+        }
+    }
+
+    pub fn insert(&self, x: &Label) -> Self {
+        let mut env = self.clone();
+        env.insert_mut(x);
+        env
+    }
+    pub fn insert_mut(&mut self, x: &Label) {
+        self.names.push(x.clone())
+    }
+    pub fn remove_mut(&mut self) {
+        self.names.pop();
+    }
+
+    pub fn unlabel_var(&self, var: &V<Label>) -> Option<AlphaVar> {
+        let V(name, idx) = var;
+        let (idx, _) = self
+            .names
+            .iter()
+            .rev()
+            .enumerate()
+            .filter(|(_, n)| *n == name)
+            .nth(*idx)?;
+        Some(AlphaVar::new(V((), idx)))
+    }
+    pub fn label_var(&self, var: &AlphaVar) -> V<Label> {
+        let name = &self.names[self.names.len() - 1 - var.idx()];
+        let idx = self
+            .names
+            .iter()
+            .rev()
+            .take(var.idx())
+            .filter(|n| *n == name)
+            .count();
+        V(name.clone(), idx)
+    }
+}
+
+impl TyEnv {
+    pub fn new() -> Self {
+        TyEnv {
+            names: NameEnv::new(),
+            items: NzEnv::new(),
+        }
+    }
+    pub fn from_nzenv_alpha(items: &NzEnv) -> Self {
+        TyEnv {
+            names: NameEnv::from_binders(
+                std::iter::repeat("_".into()).take(items.size()),
+            ),
+            items: items.clone(),
+        }
+    }
+    pub fn as_varenv(&self) -> VarEnv {
+        self.names.as_varenv()
+    }
+    pub fn as_nzenv(&self) -> &NzEnv {
+        &self.items
+    }
+    pub fn as_nameenv(&self) -> &NameEnv {
+        &self.names
+    }
+
+    pub fn insert_type(&self, x: &Label, t: Type) -> Self {
+        TyEnv {
+            names: self.names.insert(x),
+            items: self.items.insert_type(t),
+        }
+    }
+    pub fn insert_value(&self, x: &Label, e: Value) -> Self {
+        TyEnv {
+            names: self.names.insert(x),
+            items: self.items.insert_value(e),
+        }
+    }
+    pub fn lookup(&self, var: &V<Label>) -> Option<(TyExprKind, Type)> {
+        let var = self.names.unlabel_var(var)?;
+        let ty = self.items.lookup_val(&var).get_type().unwrap();
+        Some((TyExprKind::Var(var), ty))
+    }
+}
diff --git a/dhall/src/semantics/tck/mod.rs b/dhall/src/semantics/tck/mod.rs
index ba95847..28974af 100644
--- a/dhall/src/semantics/tck/mod.rs
+++ b/dhall/src/semantics/tck/mod.rs
@@ -1,4 +1,6 @@
 pub mod context;
+pub mod env;
 pub mod tyexpr;
 pub mod typecheck;
+pub(crate) use env::*;
 pub(crate) use tyexpr::*;
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index b64c519..262cda6 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -1,12 +1,10 @@
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::var::AlphaVar;
-use crate::semantics::nze::nzexpr::NameEnv;
-use crate::semantics::phase::normalize::{normalize_tyexpr_whnf, NzEnv};
+use crate::semantics::phase::normalize::normalize_tyexpr_whnf;
 use crate::semantics::phase::typecheck::rc;
 use crate::semantics::phase::Normalized;
 use crate::semantics::phase::{NormalizedExpr, ToExprOptions};
-use crate::semantics::tck::typecheck::TyEnv;
-use crate::semantics::Value;
+use crate::semantics::{NameEnv, NzEnv, TyEnv, Value};
 use crate::syntax::{ExprKind, Span, V};
 
 pub(crate) type Type = Value;
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index 7a225f7..789105f 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -3,71 +3,19 @@ use std::cmp::max;
 use std::collections::HashMap;
 
 use crate::error::{TypeError, TypeMessage};
-use crate::semantics::nze::{NameEnv, NzVar, VarEnv};
-use crate::semantics::phase::normalize::{merge_maps, NzEnv};
+use crate::semantics::phase::normalize::merge_maps;
 use crate::semantics::phase::typecheck::{
     builtin_to_value, const_to_value, type_of_builtin,
 };
 use crate::semantics::phase::Normalized;
 use crate::semantics::{
-    Binder, Closure, TyExpr, TyExprKind, Type, Value, ValueKind,
+    Binder, Closure, NzVar, TyEnv, TyExpr, TyExprKind, Type, Value, ValueKind,
 };
 use crate::syntax;
 use crate::syntax::{
-    BinOp, Builtin, Const, Expr, ExprKind, InterpolatedTextContents, Label,
-    Span, V,
+    BinOp, Builtin, Const, Expr, ExprKind, InterpolatedTextContents, Span,
 };
 
-#[derive(Debug, Clone)]
-pub(crate) struct TyEnv {
-    names: NameEnv,
-    items: NzEnv,
-}
-
-impl TyEnv {
-    pub fn new() -> Self {
-        TyEnv {
-            names: NameEnv::new(),
-            items: NzEnv::new(),
-        }
-    }
-    pub fn from_nzenv_alpha(items: &NzEnv) -> Self {
-        TyEnv {
-            names: NameEnv::from_binders(
-                std::iter::repeat("_".into()).take(items.size()),
-            ),
-            items: items.clone(),
-        }
-    }
-    pub fn as_varenv(&self) -> VarEnv {
-        self.names.as_varenv()
-    }
-    pub fn as_nzenv(&self) -> &NzEnv {
-        &self.items
-    }
-    pub fn as_nameenv(&self) -> &NameEnv {
-        &self.names
-    }
-
-    pub fn insert_type(&self, x: &Label, t: Type) -> Self {
-        TyEnv {
-            names: self.names.insert(x),
-            items: self.items.insert_type(t),
-        }
-    }
-    pub fn insert_value(&self, x: &Label, e: Value) -> Self {
-        TyEnv {
-            names: self.names.insert(x),
-            items: self.items.insert_value(e),
-        }
-    }
-    pub fn lookup(&self, var: &V<Label>) -> Option<(TyExprKind, Type)> {
-        let var = self.names.unlabel_var(var)?;
-        let ty = self.items.lookup_val(&var).get_type().unwrap();
-        Some((TyExprKind::Var(var), ty))
-    }
-}
-
 fn type_of_recordtype<'a>(
     tys: impl Iterator<Item = Cow<'a, TyExpr>>,
 ) -> Result<Type, TypeError> {
-- 
cgit v1.2.3


From a928c3c4f51d87fd942e8a81727962c00abf6808 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 29 Jan 2020 22:06:01 +0000
Subject: Cleanup variable handling

---
 dhall/src/semantics/core/value.rs                  | 10 +++----
 dhall/src/semantics/core/var.rs                    | 32 +---------------------
 dhall/src/semantics/core/visitor.rs                |  2 +-
 dhall/src/semantics/nze/env.rs                     |  2 +-
 dhall/src/semantics/tck/env.rs                     | 10 +++----
 dhall/src/semantics/tck/tyexpr.rs                  | 26 ++++++++++++++----
 dhall/src/syntax/ast/expr.rs                       | 16 ++++-------
 dhall/src/syntax/text/parser.rs                    |  2 +-
 dhall/src/syntax/text/printer.rs                   |  2 +-
 .../unit/MergeHandlersWithDifferentType.txt        |  2 --
 10 files changed, 39 insertions(+), 65 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 7334552..918826b 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
-use crate::semantics::core::var::{AlphaVar, Binder};
+use crate::semantics::core::var::Binder;
 use crate::semantics::phase::normalize::{apply_any, normalize_whnf};
 use crate::semantics::phase::typecheck::{
     builtin_to_value, builtin_to_value_env, const_to_value,
@@ -83,7 +83,7 @@ pub(crate) enum ValueKind<Value> {
     // Keep env around to construct Foo/build closures; hopefully temporary.
     AppliedBuiltin(Builtin, Vec<Value>, Vec<Value>, NzEnv),
 
-    Var(AlphaVar, NzVar),
+    Var(NzVar),
     Const(Const),
     BoolLit(bool),
     NaturalLit(Natural),
@@ -258,9 +258,7 @@ impl Value {
 
     pub fn to_tyexpr(&self, venv: VarEnv) -> TyExpr {
         let tye = match &*self.as_kind() {
-            // ValueKind::Var(v, _w) => TyExprKind::Var(*v),
-            // TODO: Only works when we don't normalize under lambdas
-            ValueKind::Var(_v, w) => TyExprKind::Var(venv.lookup(w)),
+            ValueKind::Var(v) => TyExprKind::Var(venv.lookup(v)),
             ValueKind::LamClosure {
                 binder,
                 annot,
@@ -618,7 +616,7 @@ impl Closure {
         match self {
             Closure::Closure { arg_ty, .. } => {
                 let val = Value::from_kind_and_type(
-                    ValueKind::Var(AlphaVar::default(), var),
+                    ValueKind::Var(var),
                     arg_ty.clone(),
                 );
                 self.apply(val)
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index 3458489..264b81d 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -1,16 +1,4 @@
-use crate::syntax::{Label, V};
-
-/// Stores an alpha-normalized variable.
-#[derive(Clone, Copy, Eq)]
-pub struct AlphaVar {
-    alpha: V<()>,
-}
-// TODO: temporary hopefully
-impl std::cmp::PartialEq for AlphaVar {
-    fn eq(&self, _other: &Self) -> bool {
-        true
-    }
-}
+use crate::syntax::Label;
 
 // Exactly like a Label, but equality returns always true.
 // This is so that ValueKind equality is exactly alpha-equivalence.
@@ -19,18 +7,6 @@ pub struct Binder {
     name: Label,
 }
 
-impl AlphaVar {
-    pub(crate) fn new(alpha: V<()>) -> Self {
-        AlphaVar { alpha }
-    }
-    pub(crate) fn default() -> Self {
-        AlphaVar { alpha: V((), 0) }
-    }
-    pub(crate) fn idx(&self) -> usize {
-        self.alpha.idx()
-    }
-}
-
 impl Binder {
     pub(crate) fn new(name: Label) -> Self {
         Binder { name }
@@ -47,12 +23,6 @@ impl std::cmp::PartialEq for Binder {
     }
 }
 
-impl std::fmt::Debug for AlphaVar {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "AlphaVar({})", self.alpha.1)
-    }
-}
-
 impl std::fmt::Debug for Binder {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "Binder({})", &self.name)
diff --git a/dhall/src/semantics/core/visitor.rs b/dhall/src/semantics/core/visitor.rs
index aec66f8..2191ce3 100644
--- a/dhall/src/semantics/core/visitor.rs
+++ b/dhall/src/semantics/core/visitor.rs
@@ -96,7 +96,7 @@ where
             v.visit_vec(types)?,
             env.clone(),
         ),
-        Var(v, w) => Var(v.clone(), *w),
+        Var(v) => Var(*v),
         Const(k) => Const(*k),
         BoolLit(b) => BoolLit(*b),
         NaturalLit(n) => NaturalLit(*n),
diff --git a/dhall/src/semantics/nze/env.rs b/dhall/src/semantics/nze/env.rs
index 203d99a..3c42ee7 100644
--- a/dhall/src/semantics/nze/env.rs
+++ b/dhall/src/semantics/nze/env.rs
@@ -66,7 +66,7 @@ impl NzEnv {
         let idx = self.items.len() - 1 - var.idx();
         match &self.items[idx] {
             NzEnvItem::Kept(ty) => Value::from_kind_and_type_whnf(
-                ValueKind::Var(var.clone(), NzVar::new(idx)),
+                ValueKind::Var(NzVar::new(idx)),
                 ty.clone(),
             ),
             NzEnvItem::Replaced(x) => x.clone(),
diff --git a/dhall/src/semantics/tck/env.rs b/dhall/src/semantics/tck/env.rs
index 32c2f21..1276a48 100644
--- a/dhall/src/semantics/tck/env.rs
+++ b/dhall/src/semantics/tck/env.rs
@@ -37,7 +37,7 @@ impl VarEnv {
     }
     pub fn lookup_fallible(&self, var: &NzVar) -> Option<AlphaVar> {
         let idx = self.size.checked_sub(var.idx() + 1)?;
-        Some(AlphaVar::new(V((), idx)))
+        Some(AlphaVar::new(idx))
     }
 }
 
@@ -68,7 +68,7 @@ impl NameEnv {
         self.names.pop();
     }
 
-    pub fn unlabel_var(&self, var: &V<Label>) -> Option<AlphaVar> {
+    pub fn unlabel_var(&self, var: &V) -> Option<AlphaVar> {
         let V(name, idx) = var;
         let (idx, _) = self
             .names
@@ -77,9 +77,9 @@ impl NameEnv {
             .enumerate()
             .filter(|(_, n)| *n == name)
             .nth(*idx)?;
-        Some(AlphaVar::new(V((), idx)))
+        Some(AlphaVar::new(idx))
     }
-    pub fn label_var(&self, var: &AlphaVar) -> V<Label> {
+    pub fn label_var(&self, var: &AlphaVar) -> V {
         let name = &self.names[self.names.len() - 1 - var.idx()];
         let idx = self
             .names
@@ -129,7 +129,7 @@ impl TyEnv {
             items: self.items.insert_value(e),
         }
     }
-    pub fn lookup(&self, var: &V<Label>) -> Option<(TyExprKind, Type)> {
+    pub fn lookup(&self, var: &V) -> Option<(TyExprKind, Type)> {
         let var = self.names.unlabel_var(var)?;
         let ty = self.items.lookup_val(&var).get_type().unwrap();
         Some((TyExprKind::Var(var), ty))
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index 262cda6..114bb14 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -1,5 +1,4 @@
 use crate::error::{TypeError, TypeMessage};
-use crate::semantics::core::var::AlphaVar;
 use crate::semantics::phase::normalize::normalize_tyexpr_whnf;
 use crate::semantics::phase::typecheck::rc;
 use crate::semantics::phase::Normalized;
@@ -9,6 +8,19 @@ use crate::syntax::{ExprKind, Span, V};
 
 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 {
@@ -17,11 +29,13 @@ pub(crate) struct TyExpr {
     span: Span,
 }
 
-#[derive(Debug, Clone)]
-pub(crate) enum TyExprKind {
-    Var(AlphaVar),
-    // Forbidden ExprKind variants: Var, Import, Embed
-    Expr(ExprKind<TyExpr, Normalized>),
+impl AlphaVar {
+    pub(crate) fn new(idx: usize) -> Self {
+        AlphaVar { idx }
+    }
+    pub(crate) fn idx(&self) -> usize {
+        self.idx
+    }
 }
 
 impl TyExpr {
diff --git a/dhall/src/syntax/ast/expr.rs b/dhall/src/syntax/ast/expr.rs
index 424ac34..28a0aee 100644
--- a/dhall/src/syntax/ast/expr.rs
+++ b/dhall/src/syntax/ast/expr.rs
@@ -23,8 +23,8 @@ pub enum Const {
 /// The `Label` field is the variable's name (i.e. \"`x`\").
 /// The `Int` field is a DeBruijn index.
 /// See dhall-lang/standard/semantics.md for details
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct V<Label>(pub Label, pub usize);
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct V(pub Label, pub usize);
 
 // Definition order must match precedence order for
 // pretty-printing to work correctly
@@ -112,7 +112,7 @@ pub enum ExprKind<SubExpr, Embed> {
     Const(Const),
     ///  `x`
     ///  `x@n`
-    Var(V<Label>),
+    Var(V),
     ///  `λ(x : A) -> b`
     Lam(Label, SubExpr, SubExpr),
     ///  `A -> B`
@@ -173,12 +173,6 @@ pub enum ExprKind<SubExpr, Embed> {
     Embed(Embed),
 }
 
-impl<Label> V<Label> {
-    pub(crate) fn idx(&self) -> usize {
-        self.1
-    }
-}
-
 impl<SE, E> ExprKind<SE, E> {
     pub fn traverse_ref_maybe_binder<'a, SE2, Err>(
         &'a self,
@@ -356,8 +350,8 @@ impl From<NaiveDouble> for f64 {
     }
 }
 
-impl<Label> From<Label> for V<Label> {
-    fn from(x: Label) -> V<Label> {
+impl From<Label> for V {
+    fn from(x: Label) -> V {
         V(x, 0)
     }
 }
diff --git a/dhall/src/syntax/text/parser.rs b/dhall/src/syntax/text/parser.rs
index ef1471f..681d6dd 100644
--- a/dhall/src/syntax/text/parser.rs
+++ b/dhall/src/syntax/text/parser.rs
@@ -422,7 +422,7 @@ impl DhallParser {
         ))
     }
 
-    fn variable(input: ParseInput) -> ParseResult<V<Label>> {
+    fn variable(input: ParseInput) -> ParseResult<V> {
         Ok(match_nodes!(input.into_children();
             [label(l), natural_literal(idx)] => V(l, idx),
             [label(l)] => V(l, 0),
diff --git a/dhall/src/syntax/text/printer.rs b/dhall/src/syntax/text/printer.rs
index 96f4c2a..06dd70f 100644
--- a/dhall/src/syntax/text/printer.rs
+++ b/dhall/src/syntax/text/printer.rs
@@ -496,7 +496,7 @@ impl Display for Scheme {
     }
 }
 
-impl<Label: Display> Display for V<Label> {
+impl Display for V {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         let V(x, n) = self;
         x.fmt(f)?;
diff --git a/dhall/tests/type-errors/unit/MergeHandlersWithDifferentType.txt b/dhall/tests/type-errors/unit/MergeHandlersWithDifferentType.txt
index 02d2970..6b3f8dc 100644
--- a/dhall/tests/type-errors/unit/MergeHandlersWithDifferentType.txt
+++ b/dhall/tests/type-errors/unit/MergeHandlersWithDifferentType.txt
@@ -8,7 +8,6 @@ Type error: Unhandled error: MergeHandlerTypeMismatch: Value@WHNF {
                 Replaced(
                     Value@Unevaled {
                         value: Var(
-                            AlphaVar(0),
                             Fresh(
                                 119,
                             ),
@@ -40,7 +39,6 @@ Type error: Unhandled error: MergeHandlerTypeMismatch: Value@WHNF {
                 Replaced(
                     Value@Unevaled {
                         value: Var(
-                            AlphaVar(0),
                             Fresh(
                                 120,
                             ),
-- 
cgit v1.2.3


From 655f67fb29ca847f86c3e19338757e7b031d4f50 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 11:09:39 +0000
Subject: Move builtins-related code to its own module

---
 dhall/src/semantics/builtins.rs        | 511 +++++++++++++++++++++++++++++++++
 dhall/src/semantics/core/value.rs      |  31 +-
 dhall/src/semantics/mod.rs             |   2 +
 dhall/src/semantics/phase/normalize.rs | 373 +-----------------------
 dhall/src/semantics/phase/typecheck.rs | 177 ------------
 dhall/src/semantics/tck/mod.rs         |   2 +-
 dhall/src/semantics/tck/tyexpr.rs      |   3 +-
 dhall/src/semantics/tck/typecheck.rs   |  22 +-
 8 files changed, 553 insertions(+), 568 deletions(-)
 create mode 100644 dhall/src/semantics/builtins.rs

(limited to 'dhall')

diff --git a/dhall/src/semantics/builtins.rs b/dhall/src/semantics/builtins.rs
new file mode 100644
index 0000000..58cf0d6
--- /dev/null
+++ b/dhall/src/semantics/builtins.rs
@@ -0,0 +1,511 @@
+use crate::semantics::phase::Normalized;
+use crate::semantics::{type_with, NzEnv, Value, ValueKind};
+use crate::syntax::Const::Type;
+use crate::syntax::{
+    self, Builtin, Const, Expr, ExprKind, InterpolatedText,
+    InterpolatedTextContents, Label, NaiveDouble, Span, UnspannedExpr, V,
+};
+use std::collections::HashMap;
+use std::convert::TryInto;
+
+pub(crate) fn rc<E>(x: UnspannedExpr<E>) -> Expr<E> {
+    Expr::new(x, Span::Artificial)
+}
+
+// Ad-hoc macro to help construct the types of builtins
+macro_rules! make_type {
+    (Type) => { rc(ExprKind::Const(Const::Type)) };
+    (Bool) => { rc(ExprKind::Builtin(Builtin::Bool)) };
+    (Natural) => { rc(ExprKind::Builtin(Builtin::Natural)) };
+    (Integer) => { rc(ExprKind::Builtin(Builtin::Integer)) };
+    (Double) => { rc(ExprKind::Builtin(Builtin::Double)) };
+    (Text) => { rc(ExprKind::Builtin(Builtin::Text)) };
+    ($var:ident) => {
+        rc(ExprKind::Var(V(stringify!($var).into(), 0)))
+    };
+    (Optional $ty:ident) => {
+        rc(ExprKind::App(
+            rc(ExprKind::Builtin(Builtin::Optional)),
+            make_type!($ty)
+        ))
+    };
+    (List $($rest:tt)*) => {
+        rc(ExprKind::App(
+            rc(ExprKind::Builtin(Builtin::List)),
+            make_type!($($rest)*)
+        ))
+    };
+    ({ $($label:ident : $ty:ident),* }) => {{
+        let mut kts = syntax::map::DupTreeMap::new();
+        $(
+            kts.insert(
+                Label::from(stringify!($label)),
+                make_type!($ty),
+            );
+        )*
+        rc(ExprKind::RecordType(kts))
+    }};
+    ($ty:ident -> $($rest:tt)*) => {
+        rc(ExprKind::Pi(
+            "_".into(),
+            make_type!($ty),
+            make_type!($($rest)*)
+        ))
+    };
+    (($($arg:tt)*) -> $($rest:tt)*) => {
+        rc(ExprKind::Pi(
+            "_".into(),
+            make_type!($($arg)*),
+            make_type!($($rest)*)
+        ))
+    };
+    (forall ($var:ident : $($ty:tt)*) -> $($rest:tt)*) => {
+        rc(ExprKind::Pi(
+            stringify!($var).into(),
+            make_type!($($ty)*),
+            make_type!($($rest)*)
+        ))
+    };
+}
+
+pub(crate) fn type_of_builtin<E>(b: Builtin) -> Expr<E> {
+    use Builtin::*;
+    match b {
+        Bool | Natural | Integer | Double | Text => make_type!(Type),
+        List | Optional => make_type!(
+            Type -> Type
+        ),
+
+        NaturalFold => make_type!(
+            Natural ->
+            forall (natural: Type) ->
+            forall (succ: natural -> natural) ->
+            forall (zero: natural) ->
+            natural
+        ),
+        NaturalBuild => make_type!(
+            (forall (natural: Type) ->
+                forall (succ: natural -> natural) ->
+                forall (zero: natural) ->
+                natural) ->
+            Natural
+        ),
+        NaturalIsZero | NaturalEven | NaturalOdd => make_type!(
+            Natural -> Bool
+        ),
+        NaturalToInteger => make_type!(Natural -> Integer),
+        NaturalShow => make_type!(Natural -> Text),
+        NaturalSubtract => make_type!(Natural -> Natural -> Natural),
+
+        IntegerToDouble => make_type!(Integer -> Double),
+        IntegerShow => make_type!(Integer -> Text),
+        IntegerNegate => make_type!(Integer -> Integer),
+        IntegerClamp => make_type!(Integer -> Natural),
+
+        DoubleShow => make_type!(Double -> Text),
+        TextShow => make_type!(Text -> Text),
+
+        ListBuild => make_type!(
+            forall (a: Type) ->
+            (forall (list: Type) ->
+                forall (cons: a -> list -> list) ->
+                forall (nil: list) ->
+                list) ->
+            List a
+        ),
+        ListFold => make_type!(
+            forall (a: Type) ->
+            (List a) ->
+            forall (list: Type) ->
+            forall (cons: a -> list -> list) ->
+            forall (nil: list) ->
+            list
+        ),
+        ListLength => make_type!(forall (a: Type) -> (List a) -> Natural),
+        ListHead | ListLast => {
+            make_type!(forall (a: Type) -> (List a) -> Optional a)
+        }
+        ListIndexed => make_type!(
+            forall (a: Type) ->
+            (List a) ->
+            List { index: Natural, value: a }
+        ),
+        ListReverse => make_type!(
+            forall (a: Type) -> (List a) -> List a
+        ),
+
+        OptionalBuild => make_type!(
+            forall (a: Type) ->
+            (forall (optional: Type) ->
+                forall (just: a -> optional) ->
+                forall (nothing: optional) ->
+                optional) ->
+            Optional a
+        ),
+        OptionalFold => make_type!(
+            forall (a: Type) ->
+            (Optional a) ->
+            forall (optional: Type) ->
+            forall (just: a -> optional) ->
+            forall (nothing: optional) ->
+            optional
+        ),
+        OptionalNone => make_type!(
+            forall (A: Type) -> Optional A
+        ),
+    }
+}
+
+// Ad-hoc macro to help construct closures
+macro_rules! make_closure {
+    (var($var:ident)) => {{
+        rc(ExprKind::Var(syntax::V(
+            Label::from(stringify!($var)).into(),
+            0
+        )))
+    }};
+    (λ($var:tt : $($ty:tt)*) -> $($body:tt)*) => {{
+        let var = Label::from(stringify!($var));
+        let ty = make_closure!($($ty)*);
+        let body = make_closure!($($body)*);
+        rc(ExprKind::Lam(var, ty, body))
+    }};
+    (Type) => {
+        rc(ExprKind::Const(Type))
+    };
+    (Natural) => {
+        rc(ExprKind::Builtin(Builtin::Natural))
+    };
+    (List $($ty:tt)*) => {{
+        let ty = make_closure!($($ty)*);
+        rc(ExprKind::App(
+            rc(ExprKind::Builtin(Builtin::List)),
+            ty
+        ))
+    }};
+    (Some($($v:tt)*)) => {
+        rc(ExprKind::SomeLit(
+            make_closure!($($v)*)
+        ))
+    };
+    (1 + $($v:tt)*) => {
+        rc(ExprKind::BinOp(
+            syntax::BinOp::NaturalPlus,
+            make_closure!($($v)*),
+            rc(ExprKind::NaturalLit(1))
+        ))
+    };
+    ([ $($head:tt)* ] # $($tail:tt)*) => {{
+        let head = make_closure!($($head)*);
+        let tail = make_closure!($($tail)*);
+        rc(ExprKind::BinOp(
+            syntax::BinOp::ListAppend,
+            rc(ExprKind::NEListLit(vec![head])),
+            tail,
+        ))
+    }};
+}
+
+#[allow(clippy::cognitive_complexity)]
+pub(crate) fn apply_builtin(
+    b: Builtin,
+    args: Vec<Value>,
+    ty: &Value,
+    types: Vec<Value>,
+    env: NzEnv,
+) -> ValueKind<Value> {
+    use syntax::Builtin::*;
+    use ValueKind::*;
+
+    // Small helper enum
+    enum Ret<'a> {
+        ValueKind(ValueKind<Value>),
+        Value(Value),
+        // For applications that can return a function, it's important to keep the remaining
+        // arguments to apply them to the resulting function.
+        ValueWithRemainingArgs(&'a [Value], Value),
+        DoneAsIs,
+    }
+    let make_closure = |e| {
+        type_with(&env.to_alpha_tyenv(), &e)
+            .unwrap()
+            .normalize_whnf(&env)
+    };
+
+    let ret = match (b, args.as_slice()) {
+        (OptionalNone, [t]) => Ret::ValueKind(EmptyOptionalLit(t.clone())),
+        (NaturalIsZero, [n]) => match &*n.as_whnf() {
+            NaturalLit(n) => Ret::ValueKind(BoolLit(*n == 0)),
+            _ => Ret::DoneAsIs,
+        },
+        (NaturalEven, [n]) => match &*n.as_whnf() {
+            NaturalLit(n) => Ret::ValueKind(BoolLit(*n % 2 == 0)),
+            _ => Ret::DoneAsIs,
+        },
+        (NaturalOdd, [n]) => match &*n.as_whnf() {
+            NaturalLit(n) => Ret::ValueKind(BoolLit(*n % 2 != 0)),
+            _ => Ret::DoneAsIs,
+        },
+        (NaturalToInteger, [n]) => match &*n.as_whnf() {
+            NaturalLit(n) => Ret::ValueKind(IntegerLit(*n as isize)),
+            _ => Ret::DoneAsIs,
+        },
+        (NaturalShow, [n]) => {
+            match &*n.as_whnf() {
+                NaturalLit(n) => Ret::ValueKind(TextLit(vec![
+                    InterpolatedTextContents::Text(n.to_string()),
+                ])),
+                _ => Ret::DoneAsIs,
+            }
+        }
+        (NaturalSubtract, [a, b]) => match (&*a.as_whnf(), &*b.as_whnf()) {
+            (NaturalLit(a), NaturalLit(b)) => {
+                Ret::ValueKind(NaturalLit(if b > a { b - a } else { 0 }))
+            }
+            (NaturalLit(0), _) => Ret::Value(b.clone()),
+            (_, NaturalLit(0)) => Ret::ValueKind(NaturalLit(0)),
+            _ if a == b => Ret::ValueKind(NaturalLit(0)),
+            _ => Ret::DoneAsIs,
+        },
+        (IntegerShow, [n]) => match &*n.as_whnf() {
+            IntegerLit(n) => {
+                let s = if *n < 0 {
+                    n.to_string()
+                } else {
+                    format!("+{}", n)
+                };
+                Ret::ValueKind(TextLit(vec![InterpolatedTextContents::Text(s)]))
+            }
+            _ => Ret::DoneAsIs,
+        },
+        (IntegerToDouble, [n]) => match &*n.as_whnf() {
+            IntegerLit(n) => {
+                Ret::ValueKind(DoubleLit(NaiveDouble::from(*n as f64)))
+            }
+            _ => Ret::DoneAsIs,
+        },
+        (IntegerNegate, [n]) => match &*n.as_whnf() {
+            IntegerLit(n) => Ret::ValueKind(IntegerLit(-n)),
+            _ => Ret::DoneAsIs,
+        },
+        (IntegerClamp, [n]) => match &*n.as_whnf() {
+            IntegerLit(n) => {
+                Ret::ValueKind(NaturalLit((*n).try_into().unwrap_or(0)))
+            }
+            _ => Ret::DoneAsIs,
+        },
+        (DoubleShow, [n]) => {
+            match &*n.as_whnf() {
+                DoubleLit(n) => Ret::ValueKind(TextLit(vec![
+                    InterpolatedTextContents::Text(n.to_string()),
+                ])),
+                _ => Ret::DoneAsIs,
+            }
+        }
+        (TextShow, [v]) => match &*v.as_whnf() {
+            TextLit(elts) => {
+                match elts.as_slice() {
+                    // Empty string literal.
+                    [] => {
+                        // Printing InterpolatedText takes care of all the escaping
+                        let txt: InterpolatedText<Normalized> =
+                            std::iter::empty().collect();
+                        let s = txt.to_string();
+                        Ret::ValueKind(TextLit(vec![
+                            InterpolatedTextContents::Text(s),
+                        ]))
+                    }
+                    // If there are no interpolations (invariants ensure that when there are no
+                    // interpolations, there is a single Text item) in the literal.
+                    [InterpolatedTextContents::Text(s)] => {
+                        // Printing InterpolatedText takes care of all the escaping
+                        let txt: InterpolatedText<Normalized> =
+                            std::iter::once(InterpolatedTextContents::Text(
+                                s.clone(),
+                            ))
+                            .collect();
+                        let s = txt.to_string();
+                        Ret::ValueKind(TextLit(vec![
+                            InterpolatedTextContents::Text(s),
+                        ]))
+                    }
+                    _ => Ret::DoneAsIs,
+                }
+            }
+            _ => Ret::DoneAsIs,
+        },
+        (ListLength, [_, l]) => match &*l.as_whnf() {
+            EmptyListLit(_) => Ret::ValueKind(NaturalLit(0)),
+            NEListLit(xs) => Ret::ValueKind(NaturalLit(xs.len())),
+            _ => Ret::DoneAsIs,
+        },
+        (ListHead, [_, l]) => match &*l.as_whnf() {
+            EmptyListLit(n) => Ret::ValueKind(EmptyOptionalLit(n.clone())),
+            NEListLit(xs) => {
+                Ret::ValueKind(NEOptionalLit(xs.iter().next().unwrap().clone()))
+            }
+            _ => Ret::DoneAsIs,
+        },
+        (ListLast, [_, l]) => match &*l.as_whnf() {
+            EmptyListLit(n) => Ret::ValueKind(EmptyOptionalLit(n.clone())),
+            NEListLit(xs) => Ret::ValueKind(NEOptionalLit(
+                xs.iter().rev().next().unwrap().clone(),
+            )),
+            _ => Ret::DoneAsIs,
+        },
+        (ListReverse, [_, l]) => match &*l.as_whnf() {
+            EmptyListLit(n) => Ret::ValueKind(EmptyListLit(n.clone())),
+            NEListLit(xs) => {
+                Ret::ValueKind(NEListLit(xs.iter().rev().cloned().collect()))
+            }
+            _ => Ret::DoneAsIs,
+        },
+        (ListIndexed, [_, l]) => {
+            let l_whnf = l.as_whnf();
+            match &*l_whnf {
+                EmptyListLit(_) | NEListLit(_) => {
+                    // Extract the type of the list elements
+                    let t = match &*l_whnf {
+                        EmptyListLit(t) => t.clone(),
+                        NEListLit(xs) => xs[0].get_type_not_sort(),
+                        _ => unreachable!(),
+                    };
+
+                    // Construct the returned record type: { index: Natural, value: t }
+                    let mut kts = HashMap::new();
+                    kts.insert("index".into(), Value::from_builtin(Natural));
+                    kts.insert("value".into(), t.clone());
+                    let t = Value::from_kind_and_type(
+                        RecordType(kts),
+                        Value::from_const(Type),
+                    );
+
+                    // Construct the new list, with added indices
+                    let list = match &*l_whnf {
+                        EmptyListLit(_) => EmptyListLit(t),
+                        NEListLit(xs) => NEListLit(
+                            xs.iter()
+                                .enumerate()
+                                .map(|(i, e)| {
+                                    let mut kvs = HashMap::new();
+                                    kvs.insert(
+                                        "index".into(),
+                                        Value::from_kind_and_type(
+                                            NaturalLit(i),
+                                            Value::from_builtin(
+                                                Builtin::Natural,
+                                            ),
+                                        ),
+                                    );
+                                    kvs.insert("value".into(), e.clone());
+                                    Value::from_kind_and_type(
+                                        RecordLit(kvs),
+                                        t.clone(),
+                                    )
+                                })
+                                .collect(),
+                        ),
+                        _ => unreachable!(),
+                    };
+                    Ret::ValueKind(list)
+                }
+                _ => Ret::DoneAsIs,
+            }
+        }
+        (ListBuild, [t, f]) => {
+            let list_t = Value::from_builtin(List).app(t.clone());
+            Ret::Value(
+                f.app(list_t.clone())
+                    .app(
+                        make_closure(make_closure!(
+                            λ(T : Type) ->
+                            λ(a : var(T)) ->
+                            λ(as : List var(T)) ->
+                            [ var(a) ] # var(as)
+                        ))
+                        .app(t.clone()),
+                    )
+                    .app(EmptyListLit(t.clone()).into_value_with_type(list_t)),
+            )
+        }
+        (ListFold, [_, l, _, cons, nil, r @ ..]) => match &*l.as_whnf() {
+            EmptyListLit(_) => Ret::ValueWithRemainingArgs(r, nil.clone()),
+            NEListLit(xs) => {
+                let mut v = nil.clone();
+                for x in xs.iter().cloned().rev() {
+                    v = cons.app(x).app(v);
+                }
+                Ret::ValueWithRemainingArgs(r, v)
+            }
+            _ => Ret::DoneAsIs,
+        },
+        (OptionalBuild, [t, f]) => {
+            let optional_t = Value::from_builtin(Optional).app(t.clone());
+            Ret::Value(
+                f.app(optional_t.clone())
+                    .app(
+                        make_closure(make_closure!(
+                            λ(T : Type) ->
+                            λ(a : var(T)) ->
+                            Some(var(a))
+                        ))
+                        .app(t.clone()),
+                    )
+                    .app(
+                        EmptyOptionalLit(t.clone())
+                            .into_value_with_type(optional_t),
+                    ),
+            )
+        }
+        (OptionalFold, [_, v, _, just, nothing, r @ ..]) => match &*v.as_whnf()
+        {
+            EmptyOptionalLit(_) => {
+                Ret::ValueWithRemainingArgs(r, nothing.clone())
+            }
+            NEOptionalLit(x) => {
+                Ret::ValueWithRemainingArgs(r, just.app(x.clone()))
+            }
+            _ => Ret::DoneAsIs,
+        },
+        (NaturalBuild, [f]) => Ret::Value(
+            f.app(Value::from_builtin(Natural))
+                .app(make_closure(make_closure!(
+                    λ(x : Natural) ->
+                    1 + var(x)
+                )))
+                .app(
+                    NaturalLit(0)
+                        .into_value_with_type(Value::from_builtin(Natural)),
+                ),
+        ),
+
+        (NaturalFold, [n, t, succ, zero, r @ ..]) => match &*n.as_whnf() {
+            NaturalLit(0) => Ret::ValueWithRemainingArgs(r, zero.clone()),
+            NaturalLit(n) => {
+                let fold = Value::from_builtin(NaturalFold)
+                    .app(
+                        NaturalLit(n - 1)
+                            .into_value_with_type(Value::from_builtin(Natural)),
+                    )
+                    .app(t.clone())
+                    .app(succ.clone())
+                    .app(zero.clone());
+                Ret::ValueWithRemainingArgs(r, succ.app(fold))
+            }
+            _ => Ret::DoneAsIs,
+        },
+        _ => Ret::DoneAsIs,
+    };
+    match ret {
+        Ret::ValueKind(v) => v,
+        Ret::Value(v) => v.to_whnf_check_type(ty),
+        Ret::ValueWithRemainingArgs(unconsumed_args, mut v) => {
+            let n_consumed_args = args.len() - unconsumed_args.len();
+            for x in args.into_iter().skip(n_consumed_args) {
+                v = v.app(x);
+            }
+            v.to_whnf_check_type(ty)
+        }
+        Ret::DoneAsIs => AppliedBuiltin(b, args, types, env),
+    }
+}
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 918826b..7ecb2bf 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -5,12 +5,9 @@ use std::rc::Rc;
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::var::Binder;
 use crate::semantics::phase::normalize::{apply_any, normalize_whnf};
-use crate::semantics::phase::typecheck::{
-    builtin_to_value, builtin_to_value_env, const_to_value,
-};
 use crate::semantics::phase::{Normalized, NormalizedExpr, ToExprOptions};
+use crate::semantics::{type_of_builtin, TyExpr, TyExprKind};
 use crate::semantics::{NzEnv, NzVar, VarEnv};
-use crate::semantics::{TyExpr, TyExprKind};
 use crate::syntax::{
     BinOp, Builtin, Const, ExprKind, Integer, InterpolatedTextContents, Label,
     NaiveDouble, Natural, Span,
@@ -138,13 +135,27 @@ impl Value {
         Value::new(v, WHNF, t, Span::Artificial)
     }
     pub(crate) fn from_const(c: Const) -> Self {
-        const_to_value(c)
+        let v = ValueKind::Const(c);
+        match c {
+            Const::Type => {
+                Value::from_kind_and_type(v, Value::from_const(Const::Kind))
+            }
+            Const::Kind => {
+                Value::from_kind_and_type(v, Value::from_const(Const::Sort))
+            }
+            Const::Sort => Value::const_sort(),
+        }
     }
     pub(crate) fn from_builtin(b: Builtin) -> Self {
         Self::from_builtin_env(b, &NzEnv::new())
     }
     pub(crate) fn from_builtin_env(b: Builtin, env: &NzEnv) -> Self {
-        builtin_to_value_env(b, env)
+        Value::from_kind_and_type(
+            ValueKind::from_builtin_env(b, env.clone()),
+            crate::semantics::tck::typecheck::typecheck(&type_of_builtin(b))
+                .unwrap()
+                .normalize_whnf_noenv(),
+        )
     }
 
     pub(crate) fn as_const(&self) -> Option<Const> {
@@ -361,17 +372,19 @@ impl Value {
                     ValueKind::IntegerLit(n) => ExprKind::IntegerLit(n),
                     ValueKind::DoubleLit(n) => ExprKind::DoubleLit(n),
                     ValueKind::EmptyOptionalLit(n) => ExprKind::App(
-                        builtin_to_value(Builtin::OptionalNone).to_tyexpr(venv),
+                        Value::from_builtin(Builtin::OptionalNone)
+                            .to_tyexpr(venv),
                         n,
                     ),
                     ValueKind::NEOptionalLit(n) => ExprKind::SomeLit(n),
                     ValueKind::EmptyListLit(n) => {
                         ExprKind::EmptyListLit(TyExpr::new(
                             TyExprKind::Expr(ExprKind::App(
-                                builtin_to_value(Builtin::List).to_tyexpr(venv),
+                                Value::from_builtin(Builtin::List)
+                                    .to_tyexpr(venv),
                                 n,
                             )),
-                            Some(const_to_value(Const::Type)),
+                            Some(Value::from_const(Const::Type)),
                             Span::Artificial,
                         ))
                     }
diff --git a/dhall/src/semantics/mod.rs b/dhall/src/semantics/mod.rs
index ce08334..01bbd39 100644
--- a/dhall/src/semantics/mod.rs
+++ b/dhall/src/semantics/mod.rs
@@ -1,7 +1,9 @@
+pub mod builtins;
 pub mod core;
 pub mod nze;
 pub mod phase;
 pub mod tck;
+pub(crate) use self::builtins::*;
 pub(crate) use self::core::*;
 pub(crate) use self::nze::*;
 pub(crate) use self::tck::*;
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index ce37993..2d4b4b3 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -1,373 +1,12 @@
 use std::collections::HashMap;
-use std::convert::TryInto;
 
-use crate::semantics::phase::typecheck::{
-    builtin_to_value_env, const_to_value, rc,
-};
 use crate::semantics::phase::Normalized;
-use crate::semantics::tck::typecheck::type_with;
 use crate::semantics::NzEnv;
-use crate::semantics::{Binder, Closure, TyExpr, TyExprKind, Value, ValueKind};
-use crate::syntax;
-use crate::syntax::Const::Type;
-use crate::syntax::{
-    BinOp, Builtin, Const, ExprKind, InterpolatedText,
-    InterpolatedTextContents, Label, NaiveDouble,
+use crate::semantics::{
+    apply_builtin, Binder, Closure, TyExpr, TyExprKind, Value, ValueKind,
 };
-
-// Ad-hoc macro to help construct closures
-macro_rules! make_closure {
-    (var($var:ident)) => {{
-        rc(ExprKind::Var(syntax::V(
-            Label::from(stringify!($var)).into(),
-            0
-        )))
-    }};
-    (λ($var:tt : $($ty:tt)*) -> $($body:tt)*) => {{
-        let var = Label::from(stringify!($var));
-        let ty = make_closure!($($ty)*);
-        let body = make_closure!($($body)*);
-        rc(ExprKind::Lam(var, ty, body))
-    }};
-    (Type) => {
-        rc(ExprKind::Const(Type))
-    };
-    (Natural) => {
-        rc(ExprKind::Builtin(Builtin::Natural))
-    };
-    (List $($ty:tt)*) => {{
-        let ty = make_closure!($($ty)*);
-        rc(ExprKind::App(
-            rc(ExprKind::Builtin(Builtin::List)),
-            ty
-        ))
-    }};
-    (Some($($v:tt)*)) => {
-        rc(ExprKind::SomeLit(
-            make_closure!($($v)*)
-        ))
-    };
-    (1 + $($v:tt)*) => {
-        rc(ExprKind::BinOp(
-            syntax::BinOp::NaturalPlus,
-            make_closure!($($v)*),
-            rc(ExprKind::NaturalLit(1))
-        ))
-    };
-    ([ $($head:tt)* ] # $($tail:tt)*) => {{
-        let head = make_closure!($($head)*);
-        let tail = make_closure!($($tail)*);
-        rc(ExprKind::BinOp(
-            syntax::BinOp::ListAppend,
-            rc(ExprKind::NEListLit(vec![head])),
-            tail,
-        ))
-    }};
-}
-
-#[allow(clippy::cognitive_complexity)]
-pub(crate) fn apply_builtin(
-    b: Builtin,
-    args: Vec<Value>,
-    ty: &Value,
-    types: Vec<Value>,
-    env: NzEnv,
-) -> ValueKind<Value> {
-    use syntax::Builtin::*;
-    use ValueKind::*;
-
-    // Small helper enum
-    enum Ret<'a> {
-        ValueKind(ValueKind<Value>),
-        Value(Value),
-        // For applications that can return a function, it's important to keep the remaining
-        // arguments to apply them to the resulting function.
-        ValueWithRemainingArgs(&'a [Value], Value),
-        DoneAsIs,
-    }
-    let make_closure = |e| {
-        type_with(&env.to_alpha_tyenv(), &e)
-            .unwrap()
-            .normalize_whnf(&env)
-    };
-
-    let ret = match (b, args.as_slice()) {
-        (OptionalNone, [t]) => Ret::ValueKind(EmptyOptionalLit(t.clone())),
-        (NaturalIsZero, [n]) => match &*n.as_whnf() {
-            NaturalLit(n) => Ret::ValueKind(BoolLit(*n == 0)),
-            _ => Ret::DoneAsIs,
-        },
-        (NaturalEven, [n]) => match &*n.as_whnf() {
-            NaturalLit(n) => Ret::ValueKind(BoolLit(*n % 2 == 0)),
-            _ => Ret::DoneAsIs,
-        },
-        (NaturalOdd, [n]) => match &*n.as_whnf() {
-            NaturalLit(n) => Ret::ValueKind(BoolLit(*n % 2 != 0)),
-            _ => Ret::DoneAsIs,
-        },
-        (NaturalToInteger, [n]) => match &*n.as_whnf() {
-            NaturalLit(n) => Ret::ValueKind(IntegerLit(*n as isize)),
-            _ => Ret::DoneAsIs,
-        },
-        (NaturalShow, [n]) => {
-            match &*n.as_whnf() {
-                NaturalLit(n) => Ret::ValueKind(TextLit(vec![
-                    InterpolatedTextContents::Text(n.to_string()),
-                ])),
-                _ => Ret::DoneAsIs,
-            }
-        }
-        (NaturalSubtract, [a, b]) => match (&*a.as_whnf(), &*b.as_whnf()) {
-            (NaturalLit(a), NaturalLit(b)) => {
-                Ret::ValueKind(NaturalLit(if b > a { b - a } else { 0 }))
-            }
-            (NaturalLit(0), _) => Ret::Value(b.clone()),
-            (_, NaturalLit(0)) => Ret::ValueKind(NaturalLit(0)),
-            _ if a == b => Ret::ValueKind(NaturalLit(0)),
-            _ => Ret::DoneAsIs,
-        },
-        (IntegerShow, [n]) => match &*n.as_whnf() {
-            IntegerLit(n) => {
-                let s = if *n < 0 {
-                    n.to_string()
-                } else {
-                    format!("+{}", n)
-                };
-                Ret::ValueKind(TextLit(vec![InterpolatedTextContents::Text(s)]))
-            }
-            _ => Ret::DoneAsIs,
-        },
-        (IntegerToDouble, [n]) => match &*n.as_whnf() {
-            IntegerLit(n) => {
-                Ret::ValueKind(DoubleLit(NaiveDouble::from(*n as f64)))
-            }
-            _ => Ret::DoneAsIs,
-        },
-        (IntegerNegate, [n]) => match &*n.as_whnf() {
-            IntegerLit(n) => Ret::ValueKind(IntegerLit(-n)),
-            _ => Ret::DoneAsIs,
-        },
-        (IntegerClamp, [n]) => match &*n.as_whnf() {
-            IntegerLit(n) => {
-                Ret::ValueKind(NaturalLit((*n).try_into().unwrap_or(0)))
-            }
-            _ => Ret::DoneAsIs,
-        },
-        (DoubleShow, [n]) => {
-            match &*n.as_whnf() {
-                DoubleLit(n) => Ret::ValueKind(TextLit(vec![
-                    InterpolatedTextContents::Text(n.to_string()),
-                ])),
-                _ => Ret::DoneAsIs,
-            }
-        }
-        (TextShow, [v]) => match &*v.as_whnf() {
-            TextLit(elts) => {
-                match elts.as_slice() {
-                    // Empty string literal.
-                    [] => {
-                        // Printing InterpolatedText takes care of all the escaping
-                        let txt: InterpolatedText<Normalized> =
-                            std::iter::empty().collect();
-                        let s = txt.to_string();
-                        Ret::ValueKind(TextLit(vec![
-                            InterpolatedTextContents::Text(s),
-                        ]))
-                    }
-                    // If there are no interpolations (invariants ensure that when there are no
-                    // interpolations, there is a single Text item) in the literal.
-                    [InterpolatedTextContents::Text(s)] => {
-                        // Printing InterpolatedText takes care of all the escaping
-                        let txt: InterpolatedText<Normalized> =
-                            std::iter::once(InterpolatedTextContents::Text(
-                                s.clone(),
-                            ))
-                            .collect();
-                        let s = txt.to_string();
-                        Ret::ValueKind(TextLit(vec![
-                            InterpolatedTextContents::Text(s),
-                        ]))
-                    }
-                    _ => Ret::DoneAsIs,
-                }
-            }
-            _ => Ret::DoneAsIs,
-        },
-        (ListLength, [_, l]) => match &*l.as_whnf() {
-            EmptyListLit(_) => Ret::ValueKind(NaturalLit(0)),
-            NEListLit(xs) => Ret::ValueKind(NaturalLit(xs.len())),
-            _ => Ret::DoneAsIs,
-        },
-        (ListHead, [_, l]) => match &*l.as_whnf() {
-            EmptyListLit(n) => Ret::ValueKind(EmptyOptionalLit(n.clone())),
-            NEListLit(xs) => {
-                Ret::ValueKind(NEOptionalLit(xs.iter().next().unwrap().clone()))
-            }
-            _ => Ret::DoneAsIs,
-        },
-        (ListLast, [_, l]) => match &*l.as_whnf() {
-            EmptyListLit(n) => Ret::ValueKind(EmptyOptionalLit(n.clone())),
-            NEListLit(xs) => Ret::ValueKind(NEOptionalLit(
-                xs.iter().rev().next().unwrap().clone(),
-            )),
-            _ => Ret::DoneAsIs,
-        },
-        (ListReverse, [_, l]) => match &*l.as_whnf() {
-            EmptyListLit(n) => Ret::ValueKind(EmptyListLit(n.clone())),
-            NEListLit(xs) => {
-                Ret::ValueKind(NEListLit(xs.iter().rev().cloned().collect()))
-            }
-            _ => Ret::DoneAsIs,
-        },
-        (ListIndexed, [_, l]) => {
-            let l_whnf = l.as_whnf();
-            match &*l_whnf {
-                EmptyListLit(_) | NEListLit(_) => {
-                    // Extract the type of the list elements
-                    let t = match &*l_whnf {
-                        EmptyListLit(t) => t.clone(),
-                        NEListLit(xs) => xs[0].get_type_not_sort(),
-                        _ => unreachable!(),
-                    };
-
-                    // Construct the returned record type: { index: Natural, value: t }
-                    let mut kts = HashMap::new();
-                    kts.insert("index".into(), Value::from_builtin(Natural));
-                    kts.insert("value".into(), t.clone());
-                    let t = Value::from_kind_and_type(
-                        RecordType(kts),
-                        Value::from_const(Type),
-                    );
-
-                    // Construct the new list, with added indices
-                    let list = match &*l_whnf {
-                        EmptyListLit(_) => EmptyListLit(t),
-                        NEListLit(xs) => NEListLit(
-                            xs.iter()
-                                .enumerate()
-                                .map(|(i, e)| {
-                                    let mut kvs = HashMap::new();
-                                    kvs.insert(
-                                        "index".into(),
-                                        Value::from_kind_and_type(
-                                            NaturalLit(i),
-                                            Value::from_builtin(
-                                                Builtin::Natural,
-                                            ),
-                                        ),
-                                    );
-                                    kvs.insert("value".into(), e.clone());
-                                    Value::from_kind_and_type(
-                                        RecordLit(kvs),
-                                        t.clone(),
-                                    )
-                                })
-                                .collect(),
-                        ),
-                        _ => unreachable!(),
-                    };
-                    Ret::ValueKind(list)
-                }
-                _ => Ret::DoneAsIs,
-            }
-        }
-        (ListBuild, [t, f]) => {
-            let list_t = Value::from_builtin(List).app(t.clone());
-            Ret::Value(
-                f.app(list_t.clone())
-                    .app(
-                        make_closure(make_closure!(
-                            λ(T : Type) ->
-                            λ(a : var(T)) ->
-                            λ(as : List var(T)) ->
-                            [ var(a) ] # var(as)
-                        ))
-                        .app(t.clone()),
-                    )
-                    .app(EmptyListLit(t.clone()).into_value_with_type(list_t)),
-            )
-        }
-        (ListFold, [_, l, _, cons, nil, r @ ..]) => match &*l.as_whnf() {
-            EmptyListLit(_) => Ret::ValueWithRemainingArgs(r, nil.clone()),
-            NEListLit(xs) => {
-                let mut v = nil.clone();
-                for x in xs.iter().cloned().rev() {
-                    v = cons.app(x).app(v);
-                }
-                Ret::ValueWithRemainingArgs(r, v)
-            }
-            _ => Ret::DoneAsIs,
-        },
-        (OptionalBuild, [t, f]) => {
-            let optional_t = Value::from_builtin(Optional).app(t.clone());
-            Ret::Value(
-                f.app(optional_t.clone())
-                    .app(
-                        make_closure(make_closure!(
-                            λ(T : Type) ->
-                            λ(a : var(T)) ->
-                            Some(var(a))
-                        ))
-                        .app(t.clone()),
-                    )
-                    .app(
-                        EmptyOptionalLit(t.clone())
-                            .into_value_with_type(optional_t),
-                    ),
-            )
-        }
-        (OptionalFold, [_, v, _, just, nothing, r @ ..]) => match &*v.as_whnf()
-        {
-            EmptyOptionalLit(_) => {
-                Ret::ValueWithRemainingArgs(r, nothing.clone())
-            }
-            NEOptionalLit(x) => {
-                Ret::ValueWithRemainingArgs(r, just.app(x.clone()))
-            }
-            _ => Ret::DoneAsIs,
-        },
-        (NaturalBuild, [f]) => Ret::Value(
-            f.app(Value::from_builtin(Natural))
-                .app(make_closure(make_closure!(
-                    λ(x : Natural) ->
-                    1 + var(x)
-                )))
-                .app(
-                    NaturalLit(0)
-                        .into_value_with_type(Value::from_builtin(Natural)),
-                ),
-        ),
-
-        (NaturalFold, [n, t, succ, zero, r @ ..]) => match &*n.as_whnf() {
-            NaturalLit(0) => Ret::ValueWithRemainingArgs(r, zero.clone()),
-            NaturalLit(n) => {
-                let fold = Value::from_builtin(NaturalFold)
-                    .app(
-                        NaturalLit(n - 1)
-                            .into_value_with_type(Value::from_builtin(Natural)),
-                    )
-                    .app(t.clone())
-                    .app(succ.clone())
-                    .app(zero.clone());
-                Ret::ValueWithRemainingArgs(r, succ.app(fold))
-            }
-            _ => Ret::DoneAsIs,
-        },
-        _ => Ret::DoneAsIs,
-    };
-    match ret {
-        Ret::ValueKind(v) => v,
-        Ret::Value(v) => v.to_whnf_check_type(ty),
-        Ret::ValueWithRemainingArgs(unconsumed_args, mut v) => {
-            let n_consumed_args = args.len() - unconsumed_args.len();
-            for x in args.into_iter().skip(n_consumed_args) {
-                v = v.app(x);
-            }
-            v.to_whnf_check_type(ty)
-        }
-        Ret::DoneAsIs => AppliedBuiltin(b, args, types, env),
-    }
-}
+use crate::syntax;
+use crate::syntax::{BinOp, Const, ExprKind, InterpolatedTextContents};
 
 pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
     let f_borrow = f.as_whnf();
@@ -643,8 +282,8 @@ pub(crate) fn normalize_one_layer(
             unreachable!("This case should have been handled in typecheck")
         }
         ExprKind::Annot(x, _) => Ret::Value(x),
-        ExprKind::Const(c) => Ret::Value(const_to_value(c)),
-        ExprKind::Builtin(b) => Ret::Value(builtin_to_value_env(b, env)),
+        ExprKind::Const(c) => Ret::Value(Value::from_const(c)),
+        ExprKind::Builtin(b) => Ret::Value(Value::from_builtin_env(b, env)),
         ExprKind::Assert(_) => Ret::Expr(expr),
         ExprKind::App(v, a) => Ret::Value(v.app(a)),
         ExprKind::BoolLit(b) => Ret::ValueKind(BoolLit(b)),
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index 2e22ad2..8b13789 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -1,178 +1 @@
-use crate::semantics::{NzEnv, Value, ValueKind};
-use crate::syntax;
-use crate::syntax::{
-    Builtin, Const, Expr, ExprKind, Label, Span, UnspannedExpr,
-};
 
-pub(crate) fn const_to_value(c: Const) -> Value {
-    let v = ValueKind::Const(c);
-    match c {
-        Const::Type => {
-            Value::from_kind_and_type(v, const_to_value(Const::Kind))
-        }
-        Const::Kind => {
-            Value::from_kind_and_type(v, const_to_value(Const::Sort))
-        }
-        Const::Sort => Value::const_sort(),
-    }
-}
-
-pub fn rc<E>(x: UnspannedExpr<E>) -> Expr<E> {
-    Expr::new(x, Span::Artificial)
-}
-
-// Ad-hoc macro to help construct the types of builtins
-macro_rules! make_type {
-    (Type) => { ExprKind::Const(Const::Type) };
-    (Bool) => { ExprKind::Builtin(Builtin::Bool) };
-    (Natural) => { ExprKind::Builtin(Builtin::Natural) };
-    (Integer) => { ExprKind::Builtin(Builtin::Integer) };
-    (Double) => { ExprKind::Builtin(Builtin::Double) };
-    (Text) => { ExprKind::Builtin(Builtin::Text) };
-    ($var:ident) => {
-        ExprKind::Var(syntax::V(stringify!($var).into(), 0))
-    };
-    (Optional $ty:ident) => {
-        ExprKind::App(
-            rc(ExprKind::Builtin(Builtin::Optional)),
-            rc(make_type!($ty))
-        )
-    };
-    (List $($rest:tt)*) => {
-        ExprKind::App(
-            rc(ExprKind::Builtin(Builtin::List)),
-            rc(make_type!($($rest)*))
-        )
-    };
-    ({ $($label:ident : $ty:ident),* }) => {{
-        let mut kts = syntax::map::DupTreeMap::new();
-        $(
-            kts.insert(
-                Label::from(stringify!($label)),
-                rc(make_type!($ty)),
-            );
-        )*
-        ExprKind::RecordType(kts)
-    }};
-    ($ty:ident -> $($rest:tt)*) => {
-        ExprKind::Pi(
-            "_".into(),
-            rc(make_type!($ty)),
-            rc(make_type!($($rest)*))
-        )
-    };
-    (($($arg:tt)*) -> $($rest:tt)*) => {
-        ExprKind::Pi(
-            "_".into(),
-            rc(make_type!($($arg)*)),
-            rc(make_type!($($rest)*))
-        )
-    };
-    (forall ($var:ident : $($ty:tt)*) -> $($rest:tt)*) => {
-        ExprKind::Pi(
-            stringify!($var).into(),
-            rc(make_type!($($ty)*)),
-            rc(make_type!($($rest)*))
-        )
-    };
-}
-
-pub(crate) fn type_of_builtin<E>(b: Builtin) -> Expr<E> {
-    use syntax::Builtin::*;
-    rc(match b {
-        Bool | Natural | Integer | Double | Text => make_type!(Type),
-        List | Optional => make_type!(
-            Type -> Type
-        ),
-
-        NaturalFold => make_type!(
-            Natural ->
-            forall (natural: Type) ->
-            forall (succ: natural -> natural) ->
-            forall (zero: natural) ->
-            natural
-        ),
-        NaturalBuild => make_type!(
-            (forall (natural: Type) ->
-                forall (succ: natural -> natural) ->
-                forall (zero: natural) ->
-                natural) ->
-            Natural
-        ),
-        NaturalIsZero | NaturalEven | NaturalOdd => make_type!(
-            Natural -> Bool
-        ),
-        NaturalToInteger => make_type!(Natural -> Integer),
-        NaturalShow => make_type!(Natural -> Text),
-        NaturalSubtract => make_type!(Natural -> Natural -> Natural),
-
-        IntegerToDouble => make_type!(Integer -> Double),
-        IntegerShow => make_type!(Integer -> Text),
-        IntegerNegate => make_type!(Integer -> Integer),
-        IntegerClamp => make_type!(Integer -> Natural),
-
-        DoubleShow => make_type!(Double -> Text),
-        TextShow => make_type!(Text -> Text),
-
-        ListBuild => make_type!(
-            forall (a: Type) ->
-            (forall (list: Type) ->
-                forall (cons: a -> list -> list) ->
-                forall (nil: list) ->
-                list) ->
-            List a
-        ),
-        ListFold => make_type!(
-            forall (a: Type) ->
-            (List a) ->
-            forall (list: Type) ->
-            forall (cons: a -> list -> list) ->
-            forall (nil: list) ->
-            list
-        ),
-        ListLength => make_type!(forall (a: Type) -> (List a) -> Natural),
-        ListHead | ListLast => {
-            make_type!(forall (a: Type) -> (List a) -> Optional a)
-        }
-        ListIndexed => make_type!(
-            forall (a: Type) ->
-            (List a) ->
-            List { index: Natural, value: a }
-        ),
-        ListReverse => make_type!(
-            forall (a: Type) -> (List a) -> List a
-        ),
-
-        OptionalBuild => make_type!(
-            forall (a: Type) ->
-            (forall (optional: Type) ->
-                forall (just: a -> optional) ->
-                forall (nothing: optional) ->
-                optional) ->
-            Optional a
-        ),
-        OptionalFold => make_type!(
-            forall (a: Type) ->
-            (Optional a) ->
-            forall (optional: Type) ->
-            forall (just: a -> optional) ->
-            forall (nothing: optional) ->
-            optional
-        ),
-        OptionalNone => make_type!(
-            forall (A: Type) -> Optional A
-        ),
-    })
-}
-
-pub(crate) fn builtin_to_value(b: Builtin) -> Value {
-    builtin_to_value_env(b, &NzEnv::new())
-}
-pub(crate) fn builtin_to_value_env(b: Builtin, env: &NzEnv) -> Value {
-    Value::from_kind_and_type(
-        ValueKind::from_builtin_env(b, env.clone()),
-        crate::semantics::tck::typecheck::typecheck(&type_of_builtin(b))
-            .unwrap()
-            .normalize_whnf_noenv(),
-    )
-}
diff --git a/dhall/src/semantics/tck/mod.rs b/dhall/src/semantics/tck/mod.rs
index 28974af..1df2a48 100644
--- a/dhall/src/semantics/tck/mod.rs
+++ b/dhall/src/semantics/tck/mod.rs
@@ -1,6 +1,6 @@
-pub mod context;
 pub mod env;
 pub mod tyexpr;
 pub mod typecheck;
 pub(crate) use env::*;
 pub(crate) use tyexpr::*;
+pub(crate) use typecheck::*;
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index 114bb14..bf7c130 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -1,9 +1,8 @@
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::phase::normalize::normalize_tyexpr_whnf;
-use crate::semantics::phase::typecheck::rc;
 use crate::semantics::phase::Normalized;
 use crate::semantics::phase::{NormalizedExpr, ToExprOptions};
-use crate::semantics::{NameEnv, NzEnv, TyEnv, Value};
+use crate::semantics::{rc, NameEnv, NzEnv, TyEnv, Value};
 use crate::syntax::{ExprKind, Span, V};
 
 pub(crate) type Type = Value;
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index 789105f..22ba72d 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -4,12 +4,10 @@ use std::collections::HashMap;
 
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::phase::normalize::merge_maps;
-use crate::semantics::phase::typecheck::{
-    builtin_to_value, const_to_value, type_of_builtin,
-};
 use crate::semantics::phase::Normalized;
 use crate::semantics::{
-    Binder, Closure, NzVar, TyEnv, TyExpr, TyExprKind, Type, Value, ValueKind,
+    type_of_builtin, Binder, Closure, NzVar, TyEnv, TyExpr, TyExprKind, Type,
+    Value, ValueKind,
 };
 use crate::syntax;
 use crate::syntax::{
@@ -72,19 +70,19 @@ fn type_one_layer(
         | ExprKind::Const(Const::Sort)
         | ExprKind::Embed(..) => unreachable!(), // Handled in type_with
 
-        ExprKind::Const(Const::Type) => const_to_value(Const::Kind),
-        ExprKind::Const(Const::Kind) => const_to_value(Const::Sort),
+        ExprKind::Const(Const::Type) => Value::from_const(Const::Kind),
+        ExprKind::Const(Const::Kind) => Value::from_const(Const::Sort),
         ExprKind::Builtin(b) => {
             let t_expr = type_of_builtin(*b);
             let t_tyexpr = type_with(env, &t_expr)?;
             t_tyexpr.normalize_whnf(env.as_nzenv())
         }
-        ExprKind::BoolLit(_) => builtin_to_value(Builtin::Bool),
-        ExprKind::NaturalLit(_) => builtin_to_value(Builtin::Natural),
-        ExprKind::IntegerLit(_) => builtin_to_value(Builtin::Integer),
-        ExprKind::DoubleLit(_) => builtin_to_value(Builtin::Double),
+        ExprKind::BoolLit(_) => Value::from_builtin(Builtin::Bool),
+        ExprKind::NaturalLit(_) => Value::from_builtin(Builtin::Natural),
+        ExprKind::IntegerLit(_) => Value::from_builtin(Builtin::Integer),
+        ExprKind::DoubleLit(_) => Value::from_builtin(Builtin::Double),
         ExprKind::TextLit(interpolated) => {
-            let text_type = builtin_to_value(Builtin::Text);
+            let text_type = Value::from_builtin(Builtin::Text);
             for contents in interpolated.iter() {
                 use InterpolatedTextContents::Expr;
                 if let Expr(x) = contents {
@@ -388,7 +386,7 @@ fn type_one_layer(
             Value::from_const(Const::Type)
         }
         ExprKind::BinOp(o, l, r) => {
-            let t = builtin_to_value(match o {
+            let t = Value::from_builtin(match o {
                 BinOp::BoolAnd
                 | BinOp::BoolOr
                 | BinOp::BoolEQ
-- 
cgit v1.2.3


From 7743647137d1914c280e03d6aaee81e507cff97d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 11:17:49 +0000
Subject: Remove old typecheck module

---
 dhall/src/semantics/phase/mod.rs       | 17 +++--------------
 dhall/src/semantics/phase/resolve.rs   |  8 ++------
 dhall/src/semantics/phase/typecheck.rs |  1 -
 3 files changed, 5 insertions(+), 21 deletions(-)
 delete mode 100644 dhall/src/semantics/phase/typecheck.rs

(limited to 'dhall')

diff --git a/dhall/src/semantics/phase/mod.rs b/dhall/src/semantics/phase/mod.rs
index 2727a61..f24a668 100644
--- a/dhall/src/semantics/phase/mod.rs
+++ b/dhall/src/semantics/phase/mod.rs
@@ -2,9 +2,7 @@ use std::fmt::Display;
 use std::path::Path;
 
 use crate::error::{EncodeError, Error, ImportError, TypeError};
-use crate::semantics::core::value::Value;
-use crate::semantics::core::value::ValueKind;
-use crate::semantics::tck::tyexpr::TyExpr;
+use crate::semantics::{typecheck, typecheck_with, TyExpr, Value, ValueKind};
 use crate::syntax::binary;
 use crate::syntax::{Builtin, Const, Expr};
 use resolve::ImportRoot;
@@ -12,7 +10,6 @@ use resolve::ImportRoot;
 pub(crate) mod normalize;
 pub(crate) mod parse;
 pub(crate) mod resolve;
-pub(crate) mod typecheck;
 
 pub type ParsedExpr = Expr<Normalized>;
 pub type DecodedExpr = Expr<Normalized>;
@@ -80,23 +77,15 @@ impl Parsed {
 
 impl Resolved {
     pub fn typecheck(&self) -> Result<Typed, TypeError> {
-        Ok(Typed(crate::semantics::tck::typecheck::typecheck(&self.0)?))
+        Ok(Typed(typecheck(&self.0)?))
     }
     pub fn typecheck_with(self, ty: &Normalized) -> Result<Typed, TypeError> {
-        Ok(Typed(crate::semantics::tck::typecheck::typecheck_with(
-            &self.0,
-            ty.to_expr(),
-        )?))
+        Ok(Typed(typecheck_with(&self.0, ty.to_expr())?))
     }
     /// Converts a value back to the corresponding AST expression.
     pub fn to_expr(&self) -> ResolvedExpr {
         self.0.clone()
     }
-    pub fn tck_and_normalize_new_flow(&self) -> Result<Normalized, TypeError> {
-        let val = crate::semantics::tck::typecheck::typecheck(&self.0)?
-            .normalize_whnf_noenv();
-        Ok(Normalized(val))
-    }
 }
 
 impl Typed {
diff --git a/dhall/src/semantics/phase/resolve.rs b/dhall/src/semantics/phase/resolve.rs
index 64106aa..cc4a024 100644
--- a/dhall/src/semantics/phase/resolve.rs
+++ b/dhall/src/semantics/phase/resolve.rs
@@ -52,14 +52,10 @@ fn load_import(
     import_cache: &mut ImportCache,
     import_stack: &ImportStack,
 ) -> Result<Normalized, Error> {
-    // Ok(
-    //     do_resolve_expr(Parsed::parse_file(f)?, import_cache, import_stack)?
-    //         .typecheck()?
-    //         .normalize(),
-    // )
     Ok(
         do_resolve_expr(Parsed::parse_file(f)?, import_cache, import_stack)?
-            .tck_and_normalize_new_flow()?,
+            .typecheck()?
+            .normalize(),
     )
 }
 
diff --git a/dhall/src/semantics/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
deleted file mode 100644
index 8b13789..0000000
--- a/dhall/src/semantics/phase/typecheck.rs
+++ /dev/null
@@ -1 +0,0 @@
-
-- 
cgit v1.2.3


From 5e3aaa40305a86ee90f889614c2b370184c4ef3a Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 11:20:34 +0000
Subject: Actually, no need for keeping extra args in apply_builtin

---
 dhall/src/semantics/builtins.rs | 35 ++++++++++-------------------------
 1 file changed, 10 insertions(+), 25 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/builtins.rs b/dhall/src/semantics/builtins.rs
index 58cf0d6..4cf1a7c 100644
--- a/dhall/src/semantics/builtins.rs
+++ b/dhall/src/semantics/builtins.rs
@@ -218,12 +218,9 @@ pub(crate) fn apply_builtin(
     use ValueKind::*;
 
     // Small helper enum
-    enum Ret<'a> {
+    enum Ret {
         ValueKind(ValueKind<Value>),
         Value(Value),
-        // For applications that can return a function, it's important to keep the remaining
-        // arguments to apply them to the resulting function.
-        ValueWithRemainingArgs(&'a [Value], Value),
         DoneAsIs,
     }
     let make_closure = |e| {
@@ -428,14 +425,14 @@ pub(crate) fn apply_builtin(
                     .app(EmptyListLit(t.clone()).into_value_with_type(list_t)),
             )
         }
-        (ListFold, [_, l, _, cons, nil, r @ ..]) => match &*l.as_whnf() {
-            EmptyListLit(_) => Ret::ValueWithRemainingArgs(r, nil.clone()),
+        (ListFold, [_, l, _, cons, nil]) => match &*l.as_whnf() {
+            EmptyListLit(_) => Ret::Value(nil.clone()),
             NEListLit(xs) => {
                 let mut v = nil.clone();
                 for x in xs.iter().cloned().rev() {
                     v = cons.app(x).app(v);
                 }
-                Ret::ValueWithRemainingArgs(r, v)
+                Ret::Value(v)
             }
             _ => Ret::DoneAsIs,
         },
@@ -457,14 +454,9 @@ pub(crate) fn apply_builtin(
                     ),
             )
         }
-        (OptionalFold, [_, v, _, just, nothing, r @ ..]) => match &*v.as_whnf()
-        {
-            EmptyOptionalLit(_) => {
-                Ret::ValueWithRemainingArgs(r, nothing.clone())
-            }
-            NEOptionalLit(x) => {
-                Ret::ValueWithRemainingArgs(r, just.app(x.clone()))
-            }
+        (OptionalFold, [_, v, _, just, nothing]) => match &*v.as_whnf() {
+            EmptyOptionalLit(_) => Ret::Value(nothing.clone()),
+            NEOptionalLit(x) => Ret::Value(just.app(x.clone())),
             _ => Ret::DoneAsIs,
         },
         (NaturalBuild, [f]) => Ret::Value(
@@ -479,8 +471,8 @@ pub(crate) fn apply_builtin(
                 ),
         ),
 
-        (NaturalFold, [n, t, succ, zero, r @ ..]) => match &*n.as_whnf() {
-            NaturalLit(0) => Ret::ValueWithRemainingArgs(r, zero.clone()),
+        (NaturalFold, [n, t, succ, zero]) => match &*n.as_whnf() {
+            NaturalLit(0) => Ret::Value(zero.clone()),
             NaturalLit(n) => {
                 let fold = Value::from_builtin(NaturalFold)
                     .app(
@@ -490,7 +482,7 @@ pub(crate) fn apply_builtin(
                     .app(t.clone())
                     .app(succ.clone())
                     .app(zero.clone());
-                Ret::ValueWithRemainingArgs(r, succ.app(fold))
+                Ret::Value(succ.app(fold))
             }
             _ => Ret::DoneAsIs,
         },
@@ -499,13 +491,6 @@ pub(crate) fn apply_builtin(
     match ret {
         Ret::ValueKind(v) => v,
         Ret::Value(v) => v.to_whnf_check_type(ty),
-        Ret::ValueWithRemainingArgs(unconsumed_args, mut v) => {
-            let n_consumed_args = args.len() - unconsumed_args.len();
-            for x in args.into_iter().skip(n_consumed_args) {
-                v = v.app(x);
-            }
-            v.to_whnf_check_type(ty)
-        }
         Ret::DoneAsIs => AppliedBuiltin(b, args, types, env),
     }
 }
-- 
cgit v1.2.3


From b55e291825e4e7c6899d9bf7051b816660fa43a3 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 11:24:34 +0000
Subject: Clean imports

---
 dhall/src/semantics/builtins.rs | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/builtins.rs b/dhall/src/semantics/builtins.rs
index 4cf1a7c..2efa266 100644
--- a/dhall/src/semantics/builtins.rs
+++ b/dhall/src/semantics/builtins.rs
@@ -1,8 +1,9 @@
 use crate::semantics::phase::Normalized;
-use crate::semantics::{type_with, NzEnv, Value, ValueKind};
+use crate::semantics::{typecheck, NzEnv, Value, ValueKind};
+use crate::syntax::map::DupTreeMap;
 use crate::syntax::Const::Type;
 use crate::syntax::{
-    self, Builtin, Const, Expr, ExprKind, InterpolatedText,
+    BinOp, Builtin, Const, Expr, ExprKind, InterpolatedText,
     InterpolatedTextContents, Label, NaiveDouble, Span, UnspannedExpr, V,
 };
 use std::collections::HashMap;
@@ -36,7 +37,7 @@ macro_rules! make_type {
         ))
     };
     ({ $($label:ident : $ty:ident),* }) => {{
-        let mut kts = syntax::map::DupTreeMap::new();
+        let mut kts = DupTreeMap::new();
         $(
             kts.insert(
                 Label::from(stringify!($label)),
@@ -159,7 +160,7 @@ pub(crate) fn type_of_builtin<E>(b: Builtin) -> Expr<E> {
 // Ad-hoc macro to help construct closures
 macro_rules! make_closure {
     (var($var:ident)) => {{
-        rc(ExprKind::Var(syntax::V(
+        rc(ExprKind::Var(V(
             Label::from(stringify!($var)).into(),
             0
         )))
@@ -190,7 +191,7 @@ macro_rules! make_closure {
     };
     (1 + $($v:tt)*) => {
         rc(ExprKind::BinOp(
-            syntax::BinOp::NaturalPlus,
+            BinOp::NaturalPlus,
             make_closure!($($v)*),
             rc(ExprKind::NaturalLit(1))
         ))
@@ -199,7 +200,7 @@ macro_rules! make_closure {
         let head = make_closure!($($head)*);
         let tail = make_closure!($($tail)*);
         rc(ExprKind::BinOp(
-            syntax::BinOp::ListAppend,
+            BinOp::ListAppend,
             rc(ExprKind::NEListLit(vec![head])),
             tail,
         ))
@@ -214,7 +215,7 @@ pub(crate) fn apply_builtin(
     types: Vec<Value>,
     env: NzEnv,
 ) -> ValueKind<Value> {
-    use syntax::Builtin::*;
+    use Builtin::*;
     use ValueKind::*;
 
     // Small helper enum
-- 
cgit v1.2.3


From 7dd2d64073b662acccb39601591c754279385308 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 11:24:48 +0000
Subject: No need for the current env to tck Foo/build closures

---
 dhall/src/semantics/builtins.rs |  6 +-----
 dhall/src/semantics/nze/env.rs  | 11 ++---------
 dhall/src/semantics/tck/env.rs  | 13 -------------
 3 files changed, 3 insertions(+), 27 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/builtins.rs b/dhall/src/semantics/builtins.rs
index 2efa266..0b105c7 100644
--- a/dhall/src/semantics/builtins.rs
+++ b/dhall/src/semantics/builtins.rs
@@ -224,11 +224,7 @@ pub(crate) fn apply_builtin(
         Value(Value),
         DoneAsIs,
     }
-    let make_closure = |e| {
-        type_with(&env.to_alpha_tyenv(), &e)
-            .unwrap()
-            .normalize_whnf(&env)
-    };
+    let make_closure = |e| typecheck(&e).unwrap().normalize_whnf(&env);
 
     let ret = match (b, args.as_slice()) {
         (OptionalNone, [t]) => Ret::ValueKind(EmptyOptionalLit(t.clone())),
diff --git a/dhall/src/semantics/nze/env.rs b/dhall/src/semantics/nze/env.rs
index 3c42ee7..dee597a 100644
--- a/dhall/src/semantics/nze/env.rs
+++ b/dhall/src/semantics/nze/env.rs
@@ -1,4 +1,4 @@
-use crate::semantics::{AlphaVar, TyEnv, Value, ValueKind};
+use crate::semantics::{AlphaVar, Value, ValueKind};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum NzVar {
@@ -9,7 +9,7 @@ pub(crate) enum NzVar {
 }
 
 #[derive(Debug, Clone)]
-pub(crate) enum NzEnvItem {
+enum NzEnvItem {
     // Variable is bound with given type
     Kept(Value),
     // Variable has been replaced by corresponding value
@@ -48,9 +48,6 @@ impl NzEnv {
     pub fn new() -> Self {
         NzEnv { items: Vec::new() }
     }
-    pub fn to_alpha_tyenv(&self) -> TyEnv {
-        TyEnv::from_nzenv_alpha(self)
-    }
 
     pub fn insert_type(&self, t: Value) -> Self {
         let mut env = self.clone();
@@ -72,10 +69,6 @@ impl NzEnv {
             NzEnvItem::Replaced(x) => x.clone(),
         }
     }
-
-    pub fn size(&self) -> usize {
-        self.items.len()
-    }
 }
 
 /// Ignore NzEnv when comparing; useful because we store them in `AppliedBuiltin`.
diff --git a/dhall/src/semantics/tck/env.rs b/dhall/src/semantics/tck/env.rs
index 1276a48..d4cc37d 100644
--- a/dhall/src/semantics/tck/env.rs
+++ b/dhall/src/semantics/tck/env.rs
@@ -45,11 +45,6 @@ impl NameEnv {
     pub fn new() -> Self {
         NameEnv { names: Vec::new() }
     }
-    pub fn from_binders(names: impl Iterator<Item = Label>) -> Self {
-        NameEnv {
-            names: names.collect(),
-        }
-    }
     pub fn as_varenv(&self) -> VarEnv {
         VarEnv {
             size: self.names.len(),
@@ -99,14 +94,6 @@ impl TyEnv {
             items: NzEnv::new(),
         }
     }
-    pub fn from_nzenv_alpha(items: &NzEnv) -> Self {
-        TyEnv {
-            names: NameEnv::from_binders(
-                std::iter::repeat("_".into()).take(items.size()),
-            ),
-            items: items.clone(),
-        }
-    }
     pub fn as_varenv(&self) -> VarEnv {
         self.names.as_varenv()
     }
-- 
cgit v1.2.3


From ec5fb594adf10b18a4457c3089ce4b00e2c50a39 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 11:53:18 +0000
Subject: Remove debug output in type errors

---
 dhall/src/semantics/tck/typecheck.rs               | 15 +----
 .../unit/FunctionApplicationIsNotFunction.txt      |  2 +-
 .../unit/MergeHandlerNotMatchAlternativeType.txt   | 22 +-------
 .../unit/MergeHandlersWithDifferentType.txt        | 64 +---------------------
 4 files changed, 6 insertions(+), 97 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index 22ba72d..5422e6d 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -269,7 +269,7 @@ fn type_one_layer(
                     let arg_nf = arg.normalize_nf(env.as_nzenv());
                     closure.apply(arg_nf)
                 }
-                _ => return mkerr(format!("apply to not Pi: {:?}", tf_borrow)),
+                _ => return mkerr(format!("apply to not Pi")),
             }
         }
         ExprKind::BoolIf(x, y, z) => {
@@ -447,12 +447,7 @@ fn type_one_layer(
                         match &*handler_type_borrow {
                             ValueKind::PiClosure { closure, annot, .. } => {
                                 if variant_type != annot {
-                                    // return mkerr("MergeHandlerTypeMismatch");
-                                    return mkerr(format!(
-                                        "MergeHandlerTypeMismatch: {:#?} != {:#?}",
-                                        variant_type,
-                                        annot
-                                    ));
+                                    return mkerr("MergeHandlerTypeMismatch");
                                 }
 
                                 let v = NzVar::fresh();
@@ -470,11 +465,7 @@ fn type_one_layer(
                     None => inferred_type = Some(handler_return_type),
                     Some(t) => {
                         if t != &handler_return_type {
-                            // return mkerr("MergeHandlerTypeMismatch");
-                            return mkerr(format!(
-                                "MergeHandlerTypeMismatch: {:#?} != {:#?}",
-                                t, handler_return_type,
-                            ));
+                            return mkerr("MergeHandlerTypeMismatch");
                         }
                     }
                 }
diff --git a/dhall/tests/type-errors/unit/FunctionApplicationIsNotFunction.txt b/dhall/tests/type-errors/unit/FunctionApplicationIsNotFunction.txt
index 13b0819..a72e120 100644
--- a/dhall/tests/type-errors/unit/FunctionApplicationIsNotFunction.txt
+++ b/dhall/tests/type-errors/unit/FunctionApplicationIsNotFunction.txt
@@ -1 +1 @@
-Type error: Unhandled error: apply to not Pi: AppliedBuiltin(Bool, [], [], NzEnv { items: [] })
+Type error: Unhandled error: apply to not Pi
diff --git a/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt b/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt
index 77fed39..8b729a4 100644
--- a/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt
+++ b/dhall/tests/type-errors/unit/MergeHandlerNotMatchAlternativeType.txt
@@ -1,21 +1 @@
-Type error: Unhandled error: MergeHandlerTypeMismatch: Value@WHNF {
-    value: AppliedBuiltin(
-        Natural,
-        [],
-        [],
-        NzEnv {
-            items: [],
-        },
-    ),
-    type: Type,
-} != Value@WHNF {
-    value: AppliedBuiltin(
-        Bool,
-        [],
-        [],
-        NzEnv {
-            items: [],
-        },
-    ),
-    type: Type,
-}
+Type error: Unhandled error: MergeHandlerTypeMismatch
diff --git a/dhall/tests/type-errors/unit/MergeHandlersWithDifferentType.txt b/dhall/tests/type-errors/unit/MergeHandlersWithDifferentType.txt
index 6b3f8dc..8b729a4 100644
--- a/dhall/tests/type-errors/unit/MergeHandlersWithDifferentType.txt
+++ b/dhall/tests/type-errors/unit/MergeHandlersWithDifferentType.txt
@@ -1,63 +1 @@
-Type error: Unhandled error: MergeHandlerTypeMismatch: Value@WHNF {
-    value: AppliedBuiltin(
-        Bool,
-        [],
-        [],
-        NzEnv {
-            items: [
-                Replaced(
-                    Value@Unevaled {
-                        value: Var(
-                            Fresh(
-                                119,
-                            ),
-                        ),
-                        type: Value@WHNF {
-                            value: AppliedBuiltin(
-                                Bool,
-                                [],
-                                [],
-                                NzEnv {
-                                    items: [],
-                                },
-                            ),
-                            type: Type,
-                        },
-                    },
-                ),
-            ],
-        },
-    ),
-    type: Type,
-} != Value@WHNF {
-    value: AppliedBuiltin(
-        Natural,
-        [],
-        [],
-        NzEnv {
-            items: [
-                Replaced(
-                    Value@Unevaled {
-                        value: Var(
-                            Fresh(
-                                120,
-                            ),
-                        ),
-                        type: Value@WHNF {
-                            value: AppliedBuiltin(
-                                Natural,
-                                [],
-                                [],
-                                NzEnv {
-                                    items: [],
-                                },
-                            ),
-                            type: Type,
-                        },
-                    },
-                ),
-            ],
-        },
-    ),
-    type: Type,
-}
+Type error: Unhandled error: MergeHandlerTypeMismatch
-- 
cgit v1.2.3


From 17732b041dbd44f39ce3d04a289146db9882e865 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 11:53:37 +0000
Subject: Encapsulate partially applied builtin in a separate struct

---
 dhall/src/semantics/builtins.rs        | 80 ++++++++++++++++++++++++++++++++--
 dhall/src/semantics/core/value.rs      | 30 +++----------
 dhall/src/semantics/core/visitor.rs    | 19 +++++---
 dhall/src/semantics/nze/env.rs         |  8 ----
 dhall/src/semantics/phase/normalize.rs | 31 +++++--------
 dhall/src/semantics/tck/typecheck.rs   | 26 ++++++-----
 6 files changed, 120 insertions(+), 74 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/builtins.rs b/dhall/src/semantics/builtins.rs
index 0b105c7..a23591e 100644
--- a/dhall/src/semantics/builtins.rs
+++ b/dhall/src/semantics/builtins.rs
@@ -1,5 +1,7 @@
 use crate::semantics::phase::Normalized;
-use crate::semantics::{typecheck, NzEnv, Value, ValueKind};
+use crate::semantics::{
+    typecheck, NzEnv, TyExpr, TyExprKind, Value, ValueKind, VarEnv,
+};
 use crate::syntax::map::DupTreeMap;
 use crate::syntax::Const::Type;
 use crate::syntax::{
@@ -9,6 +11,66 @@ use crate::syntax::{
 use std::collections::HashMap;
 use std::convert::TryInto;
 
+/// A partially applied builtin.
+/// Invariant: TODO
+#[derive(Debug, Clone)]
+pub(crate) struct BuiltinClosure<Value> {
+    pub env: NzEnv,
+    pub b: Builtin,
+    /// Arguments applied to the closure so far.
+    pub args: Vec<Value>,
+    /// Keeps the types of the partial applications around to be able to convert back to TyExpr.
+    /// If the args so far are `x_1`, ..., `x_n`, this contains the types of `b`, `b x1`, ...,
+    /// `b x_1 x_2 ... x_(n-1)`.
+    pub types: Vec<Value>,
+}
+
+impl BuiltinClosure<Value> {
+    pub fn new(b: Builtin, env: NzEnv) -> Self {
+        BuiltinClosure {
+            env,
+            b,
+            args: Vec::new(),
+            types: Vec::new(),
+        }
+    }
+
+    pub fn apply(
+        &self,
+        a: Value,
+        f_ty: Value,
+        ret_ty: &Value,
+    ) -> ValueKind<Value> {
+        use std::iter::once;
+        let args = self.args.iter().cloned().chain(once(a.clone())).collect();
+        let types = self.types.iter().cloned().chain(once(f_ty)).collect();
+        apply_builtin(self.b, args, ret_ty, types, self.env.clone())
+    }
+    pub fn ensure_whnf(self, ret_ty: &Value) -> ValueKind<Value> {
+        apply_builtin(self.b, self.args, ret_ty, self.types, self.env)
+    }
+    pub fn normalize_mut(&mut self) {
+        for x in self.args.iter_mut() {
+            x.normalize_mut();
+        }
+    }
+    pub fn to_tyexprkind(&self, venv: VarEnv) -> TyExprKind {
+        TyExprKind::Expr(self.args.iter().zip(self.types.iter()).fold(
+            ExprKind::Builtin(self.b),
+            |acc, (v, ty)| {
+                ExprKind::App(
+                    TyExpr::new(
+                        TyExprKind::Expr(acc),
+                        Some(ty.clone()),
+                        Span::Artificial,
+                    ),
+                    v.to_tyexpr(venv),
+                )
+            },
+        ))
+    }
+}
+
 pub(crate) fn rc<E>(x: UnspannedExpr<E>) -> Expr<E> {
     Expr::new(x, Span::Artificial)
 }
@@ -208,7 +270,7 @@ macro_rules! make_closure {
 }
 
 #[allow(clippy::cognitive_complexity)]
-pub(crate) fn apply_builtin(
+fn apply_builtin(
     b: Builtin,
     args: Vec<Value>,
     ty: &Value,
@@ -488,6 +550,18 @@ pub(crate) fn apply_builtin(
     match ret {
         Ret::ValueKind(v) => v,
         Ret::Value(v) => v.to_whnf_check_type(ty),
-        Ret::DoneAsIs => AppliedBuiltin(b, args, types, env),
+        Ret::DoneAsIs => AppliedBuiltin(BuiltinClosure {
+            b,
+            args,
+            types,
+            env,
+        }),
+    }
+}
+
+impl<Value: std::cmp::PartialEq> std::cmp::PartialEq for BuiltinClosure<Value> {
+    fn eq(&self, other: &Self) -> bool {
+        self.b == other.b && self.args == other.args
     }
 }
+impl<Value: std::cmp::Eq> std::cmp::Eq for BuiltinClosure<Value> {}
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 7ecb2bf..0fda870 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -7,7 +7,7 @@ use crate::semantics::core::var::Binder;
 use crate::semantics::phase::normalize::{apply_any, normalize_whnf};
 use crate::semantics::phase::{Normalized, NormalizedExpr, ToExprOptions};
 use crate::semantics::{type_of_builtin, TyExpr, TyExprKind};
-use crate::semantics::{NzEnv, NzVar, VarEnv};
+use crate::semantics::{BuiltinClosure, NzEnv, NzVar, VarEnv};
 use crate::syntax::{
     BinOp, Builtin, Const, ExprKind, Integer, InterpolatedTextContents, Label,
     NaiveDouble, Natural, Span,
@@ -76,9 +76,7 @@ pub(crate) enum ValueKind<Value> {
         closure: Closure,
     },
     // Invariant: in whnf, the evaluation must not be able to progress further.
-    // Keep types around to be able to recover the types of partial applications.
-    // Keep env around to construct Foo/build closures; hopefully temporary.
-    AppliedBuiltin(Builtin, Vec<Value>, Vec<Value>, NzEnv),
+    AppliedBuiltin(BuiltinClosure<Value>),
 
     Var(NzVar),
     Const(Const),
@@ -292,21 +290,7 @@ impl Value {
                     .apply_var(NzVar::new(venv.size()))
                     .to_tyexpr(venv.insert()),
             )),
-            ValueKind::AppliedBuiltin(b, args, types, _) => {
-                TyExprKind::Expr(args.into_iter().zip(types.into_iter()).fold(
-                    ExprKind::Builtin(*b),
-                    |acc, (v, ty)| {
-                        ExprKind::App(
-                            TyExpr::new(
-                                TyExprKind::Expr(acc),
-                                Some(ty.clone()),
-                                Span::Artificial,
-                            ),
-                            v.to_tyexpr(venv),
-                        )
-                    },
-                ))
-            }
+            ValueKind::AppliedBuiltin(closure) => closure.to_tyexprkind(venv),
             ValueKind::UnionConstructor(l, kts, t) => {
                 TyExprKind::Expr(ExprKind::Field(
                     TyExpr::new(
@@ -504,11 +488,7 @@ impl ValueKind<Value> {
             | ValueKind::PiClosure { annot, .. } => {
                 annot.normalize_mut();
             }
-            ValueKind::AppliedBuiltin(_, args, _, _) => {
-                for x in args.iter_mut() {
-                    x.normalize_mut();
-                }
-            }
+            ValueKind::AppliedBuiltin(closure) => closure.normalize_mut(),
             ValueKind::NEListLit(elts) => {
                 for x in elts.iter_mut() {
                     x.normalize_mut();
@@ -555,7 +535,7 @@ impl ValueKind<Value> {
         ValueKind::from_builtin_env(b, NzEnv::new())
     }
     pub(crate) fn from_builtin_env(b: Builtin, env: NzEnv) -> ValueKind<Value> {
-        ValueKind::AppliedBuiltin(b, vec![], vec![], env)
+        ValueKind::AppliedBuiltin(BuiltinClosure::new(b, env))
     }
 }
 
diff --git a/dhall/src/semantics/core/visitor.rs b/dhall/src/semantics/core/visitor.rs
index 2191ce3..a78c219 100644
--- a/dhall/src/semantics/core/visitor.rs
+++ b/dhall/src/semantics/core/visitor.rs
@@ -1,6 +1,6 @@
 use std::iter::FromIterator;
 
-use crate::semantics::{Binder, ValueKind};
+use crate::semantics::{Binder, BuiltinClosure, ValueKind};
 use crate::syntax::Label;
 
 /// A visitor trait that can be used to traverse `ValueKind`s. We need this pattern so that Rust lets
@@ -90,12 +90,17 @@ where
             annot: v.visit_val(annot)?,
             closure: closure.clone(),
         },
-        AppliedBuiltin(b, xs, types, env) => AppliedBuiltin(
-            *b,
-            v.visit_vec(xs)?,
-            v.visit_vec(types)?,
-            env.clone(),
-        ),
+        AppliedBuiltin(BuiltinClosure {
+            b,
+            args,
+            types,
+            env,
+        }) => AppliedBuiltin(BuiltinClosure {
+            b: *b,
+            args: v.visit_vec(args)?,
+            types: v.visit_vec(types)?,
+            env: env.clone(),
+        }),
         Var(v) => Var(*v),
         Const(k) => Const(*k),
         BoolLit(b) => BoolLit(*b),
diff --git a/dhall/src/semantics/nze/env.rs b/dhall/src/semantics/nze/env.rs
index dee597a..a083076 100644
--- a/dhall/src/semantics/nze/env.rs
+++ b/dhall/src/semantics/nze/env.rs
@@ -70,11 +70,3 @@ impl NzEnv {
         }
     }
 }
-
-/// Ignore NzEnv when comparing; useful because we store them in `AppliedBuiltin`.
-impl std::cmp::PartialEq for NzEnv {
-    fn eq(&self, _other: &Self) -> bool {
-        true
-    }
-}
-impl std::cmp::Eq for NzEnv {}
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index 2d4b4b3..d7720c7 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -3,10 +3,11 @@ use std::collections::HashMap;
 use crate::semantics::phase::Normalized;
 use crate::semantics::NzEnv;
 use crate::semantics::{
-    apply_builtin, Binder, Closure, TyExpr, TyExprKind, Value, ValueKind,
+    Binder, BuiltinClosure, Closure, TyExpr, TyExprKind, Value, ValueKind,
+};
+use crate::syntax::{
+    BinOp, Builtin, Const, ExprKind, InterpolatedTextContents,
 };
-use crate::syntax;
-use crate::syntax::{BinOp, Const, ExprKind, InterpolatedTextContents};
 
 pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
     let f_borrow = f.as_whnf();
@@ -14,15 +15,8 @@ pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
         ValueKind::LamClosure { closure, .. } => {
             closure.apply(a).to_whnf_check_type(ty)
         }
-        ValueKind::AppliedBuiltin(b, args, types, env) => {
-            use std::iter::once;
-            let args = args.iter().cloned().chain(once(a.clone())).collect();
-            let types = types
-                .iter()
-                .cloned()
-                .chain(once(f.get_type().unwrap()))
-                .collect();
-            apply_builtin(*b, args, ty, types, env.clone())
+        ValueKind::AppliedBuiltin(closure) => {
+            closure.apply(a, f.get_type().unwrap(), ty)
         }
         ValueKind::UnionConstructor(l, kts, uniont) => ValueKind::UnionLit(
             l.clone(),
@@ -293,12 +287,11 @@ pub(crate) fn normalize_one_layer(
         ExprKind::SomeLit(e) => Ret::ValueKind(NEOptionalLit(e)),
         ExprKind::EmptyListLit(t) => {
             let arg = match &*t.as_whnf() {
-                ValueKind::AppliedBuiltin(
-                    syntax::Builtin::List,
+                ValueKind::AppliedBuiltin(BuiltinClosure {
+                    b: Builtin::List,
                     args,
-                    _,
-                    _,
-                ) if args.len() == 1 => args[0].clone(),
+                    ..
+                }) if args.len() == 1 => args[0].clone(),
                 _ => panic!("internal type error"),
             };
             Ret::ValueKind(ValueKind::EmptyListLit(arg))
@@ -462,9 +455,7 @@ pub(crate) fn normalize_whnf(
     ty: &Value,
 ) -> ValueKind<Value> {
     match v {
-        ValueKind::AppliedBuiltin(b, args, types, env) => {
-            apply_builtin(b, args, ty, types, env)
-        }
+        ValueKind::AppliedBuiltin(closure) => closure.ensure_whnf(ty),
         ValueKind::PartialExpr(e) => normalize_one_layer(e, ty, &NzEnv::new()),
         ValueKind::TextLit(elts) => {
             ValueKind::TextLit(squash_textlit(elts.into_iter()))
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index 5422e6d..e1a9c11 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -6,10 +6,9 @@ use crate::error::{TypeError, TypeMessage};
 use crate::semantics::phase::normalize::merge_maps;
 use crate::semantics::phase::Normalized;
 use crate::semantics::{
-    type_of_builtin, Binder, Closure, NzVar, TyEnv, TyExpr, TyExprKind, Type,
-    Value, ValueKind,
+    type_of_builtin, Binder, BuiltinClosure, Closure, NzVar, TyEnv, TyExpr,
+    TyExprKind, Type, Value, ValueKind,
 };
-use crate::syntax;
 use crate::syntax::{
     BinOp, Builtin, Const, Expr, ExprKind, InterpolatedTextContents, Span,
 };
@@ -96,8 +95,11 @@ fn type_one_layer(
         ExprKind::EmptyListLit(t) => {
             let t = t.normalize_nf(env.as_nzenv());
             match &*t.as_whnf() {
-                ValueKind::AppliedBuiltin(Builtin::List, args, _, _)
-                    if args.len() == 1 => {}
+                ValueKind::AppliedBuiltin(BuiltinClosure {
+                    b: Builtin::List,
+                    args,
+                    ..
+                }) if args.len() == 1 => {}
                 _ => return mkerr("InvalidListType"),
             };
             t
@@ -365,7 +367,10 @@ fn type_one_layer(
         ExprKind::BinOp(BinOp::ListAppend, l, r) => {
             let l_ty = l.get_type()?;
             match &*l_ty.as_whnf() {
-                ValueKind::AppliedBuiltin(Builtin::List, _, _, _) => {}
+                ValueKind::AppliedBuiltin(BuiltinClosure {
+                    b: Builtin::List,
+                    ..
+                }) => {}
                 _ => return mkerr("BinOpTypeMismatch"),
             }
 
@@ -423,12 +428,11 @@ fn type_one_layer(
             let union_borrow = union_type.as_whnf();
             let variants = match &*union_borrow {
                 ValueKind::UnionType(kts) => Cow::Borrowed(kts),
-                ValueKind::AppliedBuiltin(
-                    syntax::Builtin::Optional,
+                ValueKind::AppliedBuiltin(BuiltinClosure {
+                    b: Builtin::Optional,
                     args,
-                    _,
-                    _,
-                ) if args.len() == 1 => {
+                    ..
+                }) if args.len() == 1 => {
                     let ty = &args[0];
                     let mut kts = HashMap::new();
                     kts.insert("None".into(), None);
-- 
cgit v1.2.3


From adbf51213a0df5d645d3d9423f0b284f5aff9a4e Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 14:13:09 +0000
Subject: Remove use of take_mut

---
 dhall/Cargo.toml                  |  1 -
 dhall/src/semantics/core/value.rs | 47 ++++++++++++++++++---------------------
 2 files changed, 22 insertions(+), 26 deletions(-)

(limited to 'dhall')

diff --git a/dhall/Cargo.toml b/dhall/Cargo.toml
index b795898..1479eaa 100644
--- a/dhall/Cargo.toml
+++ b/dhall/Cargo.toml
@@ -19,7 +19,6 @@ pest_consume = "1.0"
 serde = "1.0"
 serde_cbor = "0.9.0"
 smallvec = "1.0.0"
-take_mut = "0.2.2"
 
 [dev-dependencies]
 pretty_assertions = "0.6.1"
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 0fda870..f6d273c 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -412,33 +412,30 @@ impl ValueInternal {
     }
 
     fn normalize_whnf(&mut self) {
-        take_mut::take_or_recover(
-            self,
-            // Dummy value in case the other closure panics
-            || ValueInternal {
-                form: Unevaled,
-                kind: ValueKind::Const(Const::Type),
-                ty: None,
-                span: Span::Artificial,
+        let dummy = ValueInternal {
+            form: Unevaled,
+            kind: ValueKind::Const(Const::Type),
+            ty: None,
+            span: Span::Artificial,
+        };
+        let vint = std::mem::replace(self, dummy);
+        *self = match (&vint.form, &vint.ty) {
+            (Unevaled, Some(ty)) => ValueInternal {
+                form: WHNF,
+                kind: normalize_whnf(vint.kind, &ty),
+                ty: vint.ty,
+                span: vint.span,
             },
-            |vint| match (&vint.form, &vint.ty) {
-                (Unevaled, Some(ty)) => ValueInternal {
-                    form: WHNF,
-                    kind: normalize_whnf(vint.kind, &ty),
-                    ty: vint.ty,
-                    span: vint.span,
-                },
-                // `value` is `Sort`
-                (Unevaled, None) => ValueInternal {
-                    form: NF,
-                    kind: ValueKind::Const(Const::Sort),
-                    ty: None,
-                    span: vint.span,
-                },
-                // Already in WHNF
-                (WHNF, _) | (NF, _) => vint,
+            // `value` is `Sort`
+            (Unevaled, None) => ValueInternal {
+                form: NF,
+                kind: ValueKind::Const(Const::Sort),
+                ty: None,
+                span: vint.span,
             },
-        )
+            // Already in WHNF
+            (WHNF, _) | (NF, _) => vint,
+        }
     }
     fn normalize_nf(&mut self) {
         match self.form {
-- 
cgit v1.2.3


From da55a72717b247444a31b1932f85ce4abec03c14 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 14:17:50 +0000
Subject: Tweak

---
 dhall/src/semantics/core/value.rs | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index f6d273c..e69d220 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -338,11 +338,7 @@ impl Value {
                 ))
             }
             self_kind => {
-                let self_kind = self_kind
-                    .map_ref_with_special_handling_of_binders(
-                        |v| v.to_tyexpr(venv),
-                        |_, _, v| v.to_tyexpr(venv.insert()),
-                    );
+                let self_kind = self_kind.map_ref(|v| v.to_tyexpr(venv));
                 let expr = match self_kind {
                     ValueKind::Var(..)
                     | ValueKind::LamClosure { .. }
@@ -537,7 +533,7 @@ impl ValueKind<Value> {
 }
 
 impl<V> ValueKind<V> {
-    pub(crate) fn traverse_ref_with_special_handling_of_binders<'a, V2, E>(
+    fn traverse_ref_with_special_handling_of_binders<'a, V2, E>(
         &'a self,
         visit_val: impl FnMut(&'a V) -> Result<V2, E>,
         visit_under_binder: impl for<'b> FnMut(
@@ -555,7 +551,7 @@ impl<V> ValueKind<V> {
         .visit(self)
     }
 
-    pub(crate) fn map_ref_with_special_handling_of_binders<'a, V2>(
+    fn map_ref_with_special_handling_of_binders<'a, V2>(
         &'a self,
         mut map_val: impl FnMut(&'a V) -> V2,
         mut map_under_binder: impl for<'b> FnMut(&'a Binder, &'b V, &'a V) -> V2,
@@ -567,8 +563,7 @@ impl<V> ValueKind<V> {
         ))
     }
 
-    #[allow(dead_code)]
-    pub(crate) fn map_ref<'a, V2>(
+    fn map_ref<'a, V2>(
         &'a self,
         map_val: impl Fn(&'a V) -> V2,
     ) -> ValueKind<V2> {
-- 
cgit v1.2.3


From cb86493012b268ec32ad85a42b54fb1a2adab7b0 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 14:20:01 +0000
Subject: s/as_whnf/kind/

---
 dhall/src/semantics/builtins.rs        | 40 +++++++++++++++++-----------------
 dhall/src/semantics/core/value.rs      | 10 ++++-----
 dhall/src/semantics/phase/normalize.rs | 26 +++++++++++-----------
 dhall/src/semantics/tck/typecheck.rs   | 32 +++++++++++++--------------
 4 files changed, 53 insertions(+), 55 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/builtins.rs b/dhall/src/semantics/builtins.rs
index a23591e..a536261 100644
--- a/dhall/src/semantics/builtins.rs
+++ b/dhall/src/semantics/builtins.rs
@@ -290,31 +290,31 @@ fn apply_builtin(
 
     let ret = match (b, args.as_slice()) {
         (OptionalNone, [t]) => Ret::ValueKind(EmptyOptionalLit(t.clone())),
-        (NaturalIsZero, [n]) => match &*n.as_whnf() {
+        (NaturalIsZero, [n]) => match &*n.kind() {
             NaturalLit(n) => Ret::ValueKind(BoolLit(*n == 0)),
             _ => Ret::DoneAsIs,
         },
-        (NaturalEven, [n]) => match &*n.as_whnf() {
+        (NaturalEven, [n]) => match &*n.kind() {
             NaturalLit(n) => Ret::ValueKind(BoolLit(*n % 2 == 0)),
             _ => Ret::DoneAsIs,
         },
-        (NaturalOdd, [n]) => match &*n.as_whnf() {
+        (NaturalOdd, [n]) => match &*n.kind() {
             NaturalLit(n) => Ret::ValueKind(BoolLit(*n % 2 != 0)),
             _ => Ret::DoneAsIs,
         },
-        (NaturalToInteger, [n]) => match &*n.as_whnf() {
+        (NaturalToInteger, [n]) => match &*n.kind() {
             NaturalLit(n) => Ret::ValueKind(IntegerLit(*n as isize)),
             _ => Ret::DoneAsIs,
         },
         (NaturalShow, [n]) => {
-            match &*n.as_whnf() {
+            match &*n.kind() {
                 NaturalLit(n) => Ret::ValueKind(TextLit(vec![
                     InterpolatedTextContents::Text(n.to_string()),
                 ])),
                 _ => Ret::DoneAsIs,
             }
         }
-        (NaturalSubtract, [a, b]) => match (&*a.as_whnf(), &*b.as_whnf()) {
+        (NaturalSubtract, [a, b]) => match (&*a.kind(), &*b.kind()) {
             (NaturalLit(a), NaturalLit(b)) => {
                 Ret::ValueKind(NaturalLit(if b > a { b - a } else { 0 }))
             }
@@ -323,7 +323,7 @@ fn apply_builtin(
             _ if a == b => Ret::ValueKind(NaturalLit(0)),
             _ => Ret::DoneAsIs,
         },
-        (IntegerShow, [n]) => match &*n.as_whnf() {
+        (IntegerShow, [n]) => match &*n.kind() {
             IntegerLit(n) => {
                 let s = if *n < 0 {
                     n.to_string()
@@ -334,31 +334,31 @@ fn apply_builtin(
             }
             _ => Ret::DoneAsIs,
         },
-        (IntegerToDouble, [n]) => match &*n.as_whnf() {
+        (IntegerToDouble, [n]) => match &*n.kind() {
             IntegerLit(n) => {
                 Ret::ValueKind(DoubleLit(NaiveDouble::from(*n as f64)))
             }
             _ => Ret::DoneAsIs,
         },
-        (IntegerNegate, [n]) => match &*n.as_whnf() {
+        (IntegerNegate, [n]) => match &*n.kind() {
             IntegerLit(n) => Ret::ValueKind(IntegerLit(-n)),
             _ => Ret::DoneAsIs,
         },
-        (IntegerClamp, [n]) => match &*n.as_whnf() {
+        (IntegerClamp, [n]) => match &*n.kind() {
             IntegerLit(n) => {
                 Ret::ValueKind(NaturalLit((*n).try_into().unwrap_or(0)))
             }
             _ => Ret::DoneAsIs,
         },
         (DoubleShow, [n]) => {
-            match &*n.as_whnf() {
+            match &*n.kind() {
                 DoubleLit(n) => Ret::ValueKind(TextLit(vec![
                     InterpolatedTextContents::Text(n.to_string()),
                 ])),
                 _ => Ret::DoneAsIs,
             }
         }
-        (TextShow, [v]) => match &*v.as_whnf() {
+        (TextShow, [v]) => match &*v.kind() {
             TextLit(elts) => {
                 match elts.as_slice() {
                     // Empty string literal.
@@ -390,26 +390,26 @@ fn apply_builtin(
             }
             _ => Ret::DoneAsIs,
         },
-        (ListLength, [_, l]) => match &*l.as_whnf() {
+        (ListLength, [_, l]) => match &*l.kind() {
             EmptyListLit(_) => Ret::ValueKind(NaturalLit(0)),
             NEListLit(xs) => Ret::ValueKind(NaturalLit(xs.len())),
             _ => Ret::DoneAsIs,
         },
-        (ListHead, [_, l]) => match &*l.as_whnf() {
+        (ListHead, [_, l]) => match &*l.kind() {
             EmptyListLit(n) => Ret::ValueKind(EmptyOptionalLit(n.clone())),
             NEListLit(xs) => {
                 Ret::ValueKind(NEOptionalLit(xs.iter().next().unwrap().clone()))
             }
             _ => Ret::DoneAsIs,
         },
-        (ListLast, [_, l]) => match &*l.as_whnf() {
+        (ListLast, [_, l]) => match &*l.kind() {
             EmptyListLit(n) => Ret::ValueKind(EmptyOptionalLit(n.clone())),
             NEListLit(xs) => Ret::ValueKind(NEOptionalLit(
                 xs.iter().rev().next().unwrap().clone(),
             )),
             _ => Ret::DoneAsIs,
         },
-        (ListReverse, [_, l]) => match &*l.as_whnf() {
+        (ListReverse, [_, l]) => match &*l.kind() {
             EmptyListLit(n) => Ret::ValueKind(EmptyListLit(n.clone())),
             NEListLit(xs) => {
                 Ret::ValueKind(NEListLit(xs.iter().rev().cloned().collect()))
@@ -417,7 +417,7 @@ fn apply_builtin(
             _ => Ret::DoneAsIs,
         },
         (ListIndexed, [_, l]) => {
-            let l_whnf = l.as_whnf();
+            let l_whnf = l.kind();
             match &*l_whnf {
                 EmptyListLit(_) | NEListLit(_) => {
                     // Extract the type of the list elements
@@ -484,7 +484,7 @@ fn apply_builtin(
                     .app(EmptyListLit(t.clone()).into_value_with_type(list_t)),
             )
         }
-        (ListFold, [_, l, _, cons, nil]) => match &*l.as_whnf() {
+        (ListFold, [_, l, _, cons, nil]) => match &*l.kind() {
             EmptyListLit(_) => Ret::Value(nil.clone()),
             NEListLit(xs) => {
                 let mut v = nil.clone();
@@ -513,7 +513,7 @@ fn apply_builtin(
                     ),
             )
         }
-        (OptionalFold, [_, v, _, just, nothing]) => match &*v.as_whnf() {
+        (OptionalFold, [_, v, _, just, nothing]) => match &*v.kind() {
             EmptyOptionalLit(_) => Ret::Value(nothing.clone()),
             NEOptionalLit(x) => Ret::Value(just.app(x.clone())),
             _ => Ret::DoneAsIs,
@@ -530,7 +530,7 @@ fn apply_builtin(
                 ),
         ),
 
-        (NaturalFold, [n, t, succ, zero]) => match &*n.as_whnf() {
+        (NaturalFold, [n, t, succ, zero]) => match &*n.kind() {
             NaturalLit(0) => Ret::Value(zero.clone()),
             NaturalLit(n) => {
                 let fold = Value::from_builtin(NaturalFold)
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index e69d220..02c8013 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -157,7 +157,7 @@ impl Value {
     }
 
     pub(crate) fn as_const(&self) -> Option<Const> {
-        match &*self.as_whnf() {
+        match &*self.kind() {
             ValueKind::Const(c) => Some(*c),
             _ => None,
         }
@@ -180,7 +180,7 @@ impl Value {
     /// This is what you want if you want to pattern-match on the value.
     /// WARNING: drop this ref before normalizing the same value or you will run into BorrowMut
     /// panics.
-    pub(crate) fn as_whnf(&self) -> Ref<ValueKind<Value>> {
+    pub(crate) fn kind(&self) -> Ref<ValueKind<Value>> {
         self.normalize_whnf();
         self.as_kind()
     }
@@ -194,7 +194,7 @@ impl Value {
         self.to_tyexpr_noenv().to_expr(opts)
     }
     pub(crate) fn to_whnf_ignore_type(&self) -> ValueKind<Value> {
-        self.as_whnf().clone()
+        self.kind().clone()
     }
     /// Before discarding type information, check that it matches the expected return type.
     pub(crate) fn to_whnf_check_type(&self, ty: &Value) -> ValueKind<Value> {
@@ -233,7 +233,7 @@ impl Value {
     }
 
     pub(crate) fn app(&self, v: Value) -> Value {
-        let body_t = match &*self.get_type_not_sort().as_whnf() {
+        let body_t = match &*self.get_type_not_sort().kind() {
             ValueKind::PiClosure { annot, closure, .. } => {
                 v.check_type(annot);
                 closure.apply(v.clone())
@@ -617,7 +617,7 @@ impl Closure {
 // TODO: use Rc comparison to shortcut on identical pointers
 impl std::cmp::PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {
-        *self.as_whnf() == *other.as_whnf()
+        *self.kind() == *other.kind()
     }
 }
 impl std::cmp::Eq for Value {}
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index d7720c7..f36ec4a 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -10,7 +10,7 @@ use crate::syntax::{
 };
 
 pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
-    let f_borrow = f.as_whnf();
+    let f_borrow = f.kind();
     match &*f_borrow {
         ValueKind::LamClosure { closure, .. } => {
             closure.apply(a).to_whnf_check_type(ty)
@@ -47,7 +47,7 @@ pub(crate) fn squash_textlit(
             match contents {
                 Text(s) => crnt_str.push_str(&s),
                 Expr(e) => {
-                    let e_borrow = e.as_whnf();
+                    let e_borrow = e.kind();
                     match &*e_borrow {
                         ValueKind::TextLit(elts2) => {
                             inner(elts2.iter().cloned(), crnt_str, ret)
@@ -123,8 +123,8 @@ fn apply_binop<'a>(
         BoolLit, EmptyListLit, NEListLit, NaturalLit, RecordLit, RecordType,
         TextLit,
     };
-    let x_borrow = x.as_whnf();
-    let y_borrow = y.as_whnf();
+    let x_borrow = x.kind();
+    let y_borrow = y.kind();
     Some(match (o, &*x_borrow, &*y_borrow) {
         (BoolAnd, BoolLit(true), _) => Ret::ValueRef(y),
         (BoolAnd, _, BoolLit(true)) => Ret::ValueRef(x),
@@ -206,7 +206,7 @@ fn apply_binop<'a>(
             Ret::ValueRef(y)
         }
         (RecursiveRecordMerge, RecordLit(kvs1), RecordLit(kvs2)) => {
-            let ty_borrow = ty.as_whnf();
+            let ty_borrow = ty.kind();
             let kts = match &*ty_borrow {
                 RecordType(kts) => kts,
                 _ => unreachable!("Internal type error"),
@@ -286,7 +286,7 @@ pub(crate) fn normalize_one_layer(
         ExprKind::DoubleLit(n) => Ret::ValueKind(DoubleLit(n)),
         ExprKind::SomeLit(e) => Ret::ValueKind(NEOptionalLit(e)),
         ExprKind::EmptyListLit(t) => {
-            let arg = match &*t.as_whnf() {
+            let arg = match &*t.kind() {
                 ValueKind::AppliedBuiltin(BuiltinClosure {
                     b: Builtin::List,
                     args,
@@ -319,13 +319,13 @@ pub(crate) fn normalize_one_layer(
             }
         }
         ExprKind::BoolIf(ref b, ref e1, ref e2) => {
-            let b_borrow = b.as_whnf();
+            let b_borrow = b.kind();
             match &*b_borrow {
                 BoolLit(true) => Ret::ValueRef(e1),
                 BoolLit(false) => Ret::ValueRef(e2),
                 _ => {
-                    let e1_borrow = e1.as_whnf();
-                    let e2_borrow = e2.as_whnf();
+                    let e1_borrow = e1.kind();
+                    let e2_borrow = e2.kind();
                     match (&*e1_borrow, &*e2_borrow) {
                         // Simplify `if b then True else False`
                         (BoolLit(true), BoolLit(false)) => Ret::ValueRef(b),
@@ -349,7 +349,7 @@ pub(crate) fn normalize_one_layer(
             Ret::ValueKind(RecordLit(HashMap::new()))
         }
         ExprKind::Projection(ref v, ref ls) => {
-            let v_borrow = v.as_whnf();
+            let v_borrow = v.kind();
             match &*v_borrow {
                 RecordLit(kvs) => Ret::ValueKind(RecordLit(
                     ls.iter()
@@ -365,7 +365,7 @@ pub(crate) fn normalize_one_layer(
             }
         }
         ExprKind::Field(ref v, ref l) => {
-            let v_borrow = v.as_whnf();
+            let v_borrow = v.kind();
             match &*v_borrow {
                 RecordLit(kvs) => match kvs.get(l) {
                     Some(r) => Ret::Value(r.clone()),
@@ -391,8 +391,8 @@ pub(crate) fn normalize_one_layer(
         ExprKind::Completion(_, _) => unimplemented!("record completion"),
 
         ExprKind::Merge(ref handlers, ref variant, _) => {
-            let handlers_borrow = handlers.as_whnf();
-            let variant_borrow = variant.as_whnf();
+            let handlers_borrow = handlers.kind();
+            let variant_borrow = variant.kind();
             match (&*handlers_borrow, &*variant_borrow) {
                 (RecordLit(kvs), UnionConstructor(l, _, _)) => match kvs.get(l)
                 {
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index e1a9c11..0c5e779 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -94,7 +94,7 @@ fn type_one_layer(
         }
         ExprKind::EmptyListLit(t) => {
             let t = t.normalize_nf(env.as_nzenv());
-            match &*t.as_whnf() {
+            match &*t.kind() {
                 ValueKind::AppliedBuiltin(BuiltinClosure {
                     b: Builtin::List,
                     args,
@@ -189,7 +189,7 @@ fn type_one_layer(
             Value::from_const(k)
         }
         ExprKind::Field(scrut, x) => {
-            match &*scrut.get_type()?.as_whnf() {
+            match &*scrut.get_type()?.kind() {
                 ValueKind::RecordType(kts) => match kts.get(&x) {
                     Some(tth) => tth.clone(),
                     None => return mkerr("MissingRecordField"),
@@ -197,7 +197,7 @@ fn type_one_layer(
                 // TODO: branch here only when scrut.get_type() is a Const
                 _ => {
                     let scrut_nf = scrut.normalize_nf(env.as_nzenv());
-                    let scrut_nf_borrow = scrut_nf.as_whnf();
+                    let scrut_nf_borrow = scrut_nf.kind();
                     match &*scrut_nf_borrow {
                         ValueKind::UnionType(kts) => match kts.get(x) {
                             // Constructor has type T -> < x: T, ... >
@@ -244,7 +244,7 @@ fn type_one_layer(
         }
         ExprKind::Assert(t) => {
             let t = t.normalize_whnf(env.as_nzenv());
-            match &*t.as_whnf() {
+            match &*t.kind() {
                 ValueKind::Equivalence(x, y) if x == y => {}
                 ValueKind::Equivalence(..) => return mkerr("AssertMismatch"),
                 _ => return mkerr("AssertMustTakeEquivalence"),
@@ -253,7 +253,7 @@ fn type_one_layer(
         }
         ExprKind::App(f, arg) => {
             let tf = f.get_type()?;
-            let tf_borrow = tf.as_whnf();
+            let tf_borrow = tf.kind();
             match &*tf_borrow {
                 ValueKind::PiClosure { annot, closure, .. } => {
                     if arg.get_type()? != *annot {
@@ -275,9 +275,7 @@ fn type_one_layer(
             }
         }
         ExprKind::BoolIf(x, y, z) => {
-            if *x.get_type()?.as_whnf()
-                != ValueKind::from_builtin(Builtin::Bool)
-            {
+            if *x.get_type()?.kind() != ValueKind::from_builtin(Builtin::Bool) {
                 return mkerr("InvalidPredicate");
             }
             if y.get_type()?.get_type()?.as_const() != Some(Const::Type) {
@@ -297,14 +295,14 @@ fn type_one_layer(
             let y_type = y.get_type()?;
 
             // Extract the LHS record type
-            let x_type_borrow = x_type.as_whnf();
+            let x_type_borrow = x_type.kind();
             let kts_x = match &*x_type_borrow {
                 ValueKind::RecordType(kts) => kts,
                 _ => return mkerr("MustCombineRecord"),
             };
 
             // Extract the RHS record type
-            let y_type_borrow = y_type.as_whnf();
+            let y_type_borrow = y_type.kind();
             let kts_y = match &*y_type_borrow {
                 ValueKind::RecordType(kts) => kts,
                 _ => return mkerr("MustCombineRecord"),
@@ -336,8 +334,8 @@ fn type_one_layer(
         ExprKind::BinOp(BinOp::RecursiveRecordTypeMerge, x, y) => {
             let x_val = x.normalize_whnf(env.as_nzenv());
             let y_val = y.normalize_whnf(env.as_nzenv());
-            let x_val_borrow = x_val.as_whnf();
-            let y_val_borrow = y_val.as_whnf();
+            let x_val_borrow = x_val.kind();
+            let y_val_borrow = y_val.kind();
             let kts_x = match &*x_val_borrow {
                 ValueKind::RecordType(kts) => kts,
                 _ => return mkerr("RecordTypeMergeRequiresRecordType"),
@@ -366,7 +364,7 @@ fn type_one_layer(
         }
         ExprKind::BinOp(BinOp::ListAppend, l, r) => {
             let l_ty = l.get_type()?;
-            match &*l_ty.as_whnf() {
+            match &*l_ty.kind() {
                 ValueKind::AppliedBuiltin(BuiltinClosure {
                     b: Builtin::List,
                     ..
@@ -418,14 +416,14 @@ fn type_one_layer(
         }
         ExprKind::Merge(record, union, type_annot) => {
             let record_type = record.get_type()?;
-            let record_borrow = record_type.as_whnf();
+            let record_borrow = record_type.kind();
             let handlers = match &*record_borrow {
                 ValueKind::RecordType(kts) => kts,
                 _ => return mkerr("Merge1ArgMustBeRecord"),
             };
 
             let union_type = union.get_type()?;
-            let union_borrow = union_type.as_whnf();
+            let union_borrow = union_type.kind();
             let variants = match &*union_borrow {
                 ValueKind::UnionType(kts) => Cow::Borrowed(kts),
                 ValueKind::AppliedBuiltin(BuiltinClosure {
@@ -447,7 +445,7 @@ fn type_one_layer(
                 let handler_return_type = match variants.get(x) {
                     // Union alternative with type
                     Some(Some(variant_type)) => {
-                        let handler_type_borrow = handler_type.as_whnf();
+                        let handler_type_borrow = handler_type.kind();
                         match &*handler_type_borrow {
                             ValueKind::PiClosure { closure, annot, .. } => {
                                 if variant_type != annot {
@@ -498,7 +496,7 @@ fn type_one_layer(
         ExprKind::ToMap(_, _) => unimplemented!("toMap"),
         ExprKind::Projection(record, labels) => {
             let record_type = record.get_type()?;
-            let record_type_borrow = record_type.as_whnf();
+            let record_type_borrow = record_type.kind();
             let kts = match &*record_type_borrow {
                 ValueKind::RecordType(kts) => kts,
                 _ => return mkerr("ProjectionMustBeRecord"),
-- 
cgit v1.2.3


From 25bd09136742403d7f3d6c6143f72e6687f39457 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 14:48:38 +0000
Subject: Make unnormalized Values unobservable

---
 dhall/src/semantics/core/value.rs | 9 ++-------
 dhall/src/semantics/tck/tyexpr.rs | 4 +---
 2 files changed, 3 insertions(+), 10 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 02c8013..af01177 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -172,17 +172,12 @@ impl Value {
     fn as_internal_mut(&self) -> RefMut<ValueInternal> {
         self.0.borrow_mut()
     }
-    /// WARNING: The returned ValueKind may be entirely unnormalized, in particular it may just be an
-    /// unevaled PartialExpr. You probably want to use `as_whnf`.
-    pub(crate) fn as_kind(&self) -> Ref<ValueKind<Value>> {
-        Ref::map(self.as_internal(), ValueInternal::as_kind)
-    }
     /// This is what you want if you want to pattern-match on the value.
     /// WARNING: drop this ref before normalizing the same value or you will run into BorrowMut
     /// panics.
     pub(crate) fn kind(&self) -> Ref<ValueKind<Value>> {
         self.normalize_whnf();
-        self.as_kind()
+        Ref::map(self.as_internal(), ValueInternal::as_kind)
     }
 
     /// Converts a value back to the corresponding AST expression.
@@ -266,7 +261,7 @@ impl Value {
     }
 
     pub fn to_tyexpr(&self, venv: VarEnv) -> TyExpr {
-        let tye = match &*self.as_kind() {
+        let tye = match &*self.kind() {
             ValueKind::Var(v) => TyExprKind::Var(venv.lookup(v)),
             ValueKind::LamClosure {
                 binder,
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index bf7c130..5492b8b 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -76,9 +76,7 @@ impl TyExpr {
         self.normalize_whnf(&NzEnv::new())
     }
     pub fn normalize_nf(&self, env: &NzEnv) -> Value {
-        let mut val = self.normalize_whnf(env);
-        val.normalize_mut();
-        val
+        self.normalize_whnf(env)
     }
     pub fn normalize_nf_noenv(&self) -> Value {
         self.normalize_nf(&NzEnv::new())
-- 
cgit v1.2.3


From 837298f26e07bb264a6b6f0286cbb811553b0477 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 14:49:17 +0000
Subject: Increase encapsulation for Closures

---
 dhall/src/semantics/core/value.rs    | 34 +++++++++++++++++++++++++++-------
 dhall/src/semantics/tck/typecheck.rs | 10 +++++-----
 2 files changed, 32 insertions(+), 12 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index af01177..bf75710 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -270,9 +270,7 @@ impl Value {
             } => TyExprKind::Expr(ExprKind::Lam(
                 binder.to_label(),
                 annot.to_tyexpr(venv),
-                closure
-                    .apply_var(NzVar::new(venv.size()))
-                    .to_tyexpr(venv.insert()),
+                closure.to_tyexpr(venv),
             )),
             ValueKind::PiClosure {
                 binder,
@@ -281,9 +279,7 @@ impl Value {
             } => TyExprKind::Expr(ExprKind::Pi(
                 binder.to_label(),
                 annot.to_tyexpr(venv),
-                closure
-                    .apply_var(NzVar::new(venv.size()))
-                    .to_tyexpr(venv.insert()),
+                closure.to_tyexpr(venv),
             )),
             ValueKind::AppliedBuiltin(closure) => closure.to_tyexprkind(venv),
             ValueKind::UnionConstructor(l, kts, t) => {
@@ -576,12 +572,14 @@ impl Closure {
             body,
         }
     }
+    /// New closure that ignores its argument
     pub fn new_constant(env: &NzEnv, body: TyExpr) -> Self {
         Closure::ConstantClosure {
             env: env.clone(),
             body,
         }
     }
+
     pub fn apply(&self, val: Value) -> Value {
         match self {
             Closure::Closure { env, body, .. } => {
@@ -592,7 +590,7 @@ impl Closure {
             }
         }
     }
-    pub fn apply_var(&self, var: NzVar) -> Value {
+    fn apply_var(&self, var: NzVar) -> Value {
         match self {
             Closure::Closure { arg_ty, .. } => {
                 let val = Value::from_kind_and_type(
@@ -606,6 +604,28 @@ impl Closure {
             }
         }
     }
+
+    /// Convert this closure to a TyExpr
+    pub fn to_tyexpr(&self, venv: VarEnv) -> TyExpr {
+        self.apply_var(NzVar::new(venv.size()))
+            .to_tyexpr(venv.insert())
+    }
+    /// If the closure variable is free in the closure, return Err. Otherwise, return the value
+    /// with that free variable remove.
+    pub fn remove_binder(&self) -> Result<Value, ()> {
+        let v = NzVar::fresh();
+        match self {
+            Closure::Closure { .. } => {
+                // TODO: handle case where variable is used in closure
+                // TODO: return information about where the variable is used
+                Ok(self.apply_var(v))
+            }
+            Closure::ConstantClosure { .. } => {
+                // Ok: the variable is indeed ignored
+                Ok(self.apply_var(v))
+            }
+        }
+    }
 }
 
 /// Compare two values for equality modulo alpha/beta-equivalence.
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index 0c5e779..bc1c87f 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -6,7 +6,7 @@ use crate::error::{TypeError, TypeMessage};
 use crate::semantics::phase::normalize::merge_maps;
 use crate::semantics::phase::Normalized;
 use crate::semantics::{
-    type_of_builtin, Binder, BuiltinClosure, Closure, NzVar, TyEnv, TyExpr,
+    type_of_builtin, Binder, BuiltinClosure, Closure, TyEnv, TyExpr,
     TyExprKind, Type, Value, ValueKind,
 };
 use crate::syntax::{
@@ -48,7 +48,7 @@ fn type_of_function(src: Type, tgt: Type) -> Result<Type, TypeError> {
     Ok(Value::from_const(function_check(ks, kt)))
 }
 
-fn mkerr<T>(x: impl ToString) -> Result<T, TypeError> {
+fn mkerr<T, S: ToString>(x: S) -> Result<T, TypeError> {
     Err(TypeError::new(TypeMessage::Custom(x.to_string())))
 }
 
@@ -452,9 +452,9 @@ fn type_one_layer(
                                     return mkerr("MergeHandlerTypeMismatch");
                                 }
 
-                                let v = NzVar::fresh();
-                                // TODO: handle case where variable is used in closure
-                                closure.apply_var(v)
+                                closure.remove_binder().or_else(|()| {
+                                    mkerr("MergeReturnTypeIsDependent")
+                                })?
                             }
                             _ => return mkerr("NotAFunction"),
                         }
-- 
cgit v1.2.3


From 4c4ec8614b84d72fee4d765857325b73dad16183 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 14:52:35 +0000
Subject: Remove NF marker; it was premature optimization

---
 dhall/src/semantics/core/value.rs | 33 +++++++++++----------------------
 1 file changed, 11 insertions(+), 22 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index bf75710..4c844ee 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -13,7 +13,7 @@ use crate::syntax::{
     NaiveDouble, Natural, Span,
 };
 
-use self::Form::{Unevaled, NF, WHNF};
+use self::Form::{Unevaled, WHNF};
 
 /// Stores a possibly unevaluated value. Gets (partially) normalized on-demand, sharing computation
 /// automatically. Uses a RefCell to share computation.
@@ -25,7 +25,6 @@ use self::Form::{Unevaled, NF, WHNF};
 pub(crate) struct Value(Rc<RefCell<ValueInternal>>);
 
 /// Invariant: if `form` is `WHNF`, `value` must be in Weak Head Normal Form
-/// Invariant: if `form` is `NF`, `value` must be fully normalized
 #[derive(Debug)]
 struct ValueInternal {
     form: Form,
@@ -42,12 +41,10 @@ pub(crate) enum Form {
     /// Weak Head Normal Form, i.e. normalized up to the first constructor, but subexpressions may
     /// not be normalized. This means that the first constructor of the contained ValueKind is the first
     /// constructor of the final Normal Form (NF).
-    WHNF,
-    /// Normal Form, i.e. completely normalized.
-    /// When all the Values in a ValueKind are at least in WHNF, and recursively so, then the
+    /// When all the Values in a ValueKind are in WHNF, and recursively so, then the
     /// ValueKind is in NF. This is because WHNF ensures that we have the first constructor of the NF; so
     /// if we have the first constructor of the NF at all levels, we actually have the NF.
-    NF,
+    WHNF,
 }
 
 #[derive(Debug, Clone)]
@@ -116,7 +113,7 @@ impl Value {
     }
     pub(crate) fn const_sort() -> Value {
         ValueInternal {
-            form: NF,
+            form: WHNF,
             kind: ValueKind::Const(Const::Sort),
             ty: None,
             span: Span::Artificial,
@@ -219,8 +216,8 @@ impl Value {
                 drop(borrow);
                 self.as_internal_mut().normalize_whnf();
             }
-            // Already at least in WHNF
-            WHNF | NF => {}
+            // Already in WHNF
+            WHNF => {}
         }
     }
     pub(crate) fn normalize_nf(&self) {
@@ -415,28 +412,20 @@ impl ValueInternal {
             },
             // `value` is `Sort`
             (Unevaled, None) => ValueInternal {
-                form: NF,
+                form: WHNF,
                 kind: ValueKind::Const(Const::Sort),
                 ty: None,
                 span: vint.span,
             },
             // Already in WHNF
-            (WHNF, _) | (NF, _) => vint,
+            (WHNF, _) => vint,
         }
     }
     fn normalize_nf(&mut self) {
-        match self.form {
-            Unevaled => {
-                self.normalize_whnf();
-                self.normalize_nf();
-            }
-            WHNF => {
-                self.kind.normalize_mut();
-                self.form = NF;
-            }
-            // Already in NF
-            NF => {}
+        if let Unevaled = self.form {
+            self.normalize_whnf();
         }
+        self.kind.normalize_mut();
     }
 
     fn get_type(&self) -> Result<&Value, TypeError> {
-- 
cgit v1.2.3


From 67bbbafbc9730d74e20e5ac082ae9a87bdf2234e Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 16:39:25 +0000
Subject: Introduce Thunks and normalize lazily

---
 dhall/src/semantics/builtins.rs        |  2 +-
 dhall/src/semantics/core/value.rs      | 71 +++++++++++++++++++++++++++-------
 dhall/src/semantics/core/visitor.rs    |  1 +
 dhall/src/semantics/phase/mod.rs       |  2 +-
 dhall/src/semantics/phase/normalize.rs | 11 +++---
 dhall/src/semantics/tck/tyexpr.rs      | 22 ++++++-----
 dhall/src/semantics/tck/typecheck.rs   | 31 +++++++--------
 7 files changed, 95 insertions(+), 45 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/builtins.rs b/dhall/src/semantics/builtins.rs
index a536261..9d10d89 100644
--- a/dhall/src/semantics/builtins.rs
+++ b/dhall/src/semantics/builtins.rs
@@ -286,7 +286,7 @@ fn apply_builtin(
         Value(Value),
         DoneAsIs,
     }
-    let make_closure = |e| typecheck(&e).unwrap().normalize_whnf(&env);
+    let make_closure = |e| typecheck(&e).unwrap().eval(&env);
 
     let ret = match (b, args.as_slice()) {
         (OptionalNone, [t]) => Ret::ValueKind(EmptyOptionalLit(t.clone())),
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 4c844ee..c881a9a 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -4,9 +4,11 @@ use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::core::var::Binder;
-use crate::semantics::phase::normalize::{apply_any, normalize_whnf};
+use crate::semantics::phase::normalize::{
+    apply_any, normalize_tyexpr_whnf, normalize_whnf,
+};
 use crate::semantics::phase::{Normalized, NormalizedExpr, ToExprOptions};
-use crate::semantics::{type_of_builtin, TyExpr, TyExprKind};
+use crate::semantics::{type_of_builtin, typecheck, TyExpr, TyExprKind};
 use crate::semantics::{BuiltinClosure, NzEnv, NzVar, VarEnv};
 use crate::syntax::{
     BinOp, Builtin, Const, ExprKind, Integer, InterpolatedTextContents, Label,
@@ -47,6 +49,14 @@ pub(crate) enum Form {
     WHNF,
 }
 
+/// An unevaluated subexpression
+#[derive(Debug, Clone)]
+pub(crate) struct Thunk {
+    env: NzEnv,
+    body: TyExpr,
+}
+
+/// An unevaluated subexpression that takes an argument.
 #[derive(Debug, Clone)]
 pub(crate) enum Closure {
     /// Normal closure
@@ -99,6 +109,8 @@ pub(crate) enum ValueKind<Value> {
     Equivalence(Value, Value),
     // Invariant: in whnf, this must not contain a value captured by one of the variants above.
     PartialExpr(ExprKind<Value, Normalized>),
+    // Invariant: absent in whnf
+    Thunk(Thunk),
 }
 
 impl Value {
@@ -120,6 +132,15 @@ impl Value {
         }
         .into_value()
     }
+    pub(crate) fn new_thunk(env: &NzEnv, tye: TyExpr) -> Value {
+        ValueInternal {
+            form: Unevaled,
+            kind: ValueKind::Thunk(Thunk::new(env, tye.clone())),
+            ty: tye.get_type().ok(),
+            span: tye.span().clone(),
+        }
+        .into_value()
+    }
     pub(crate) fn from_kind_and_type(v: ValueKind<Value>, t: Value) -> Value {
         Value::new(v, Unevaled, t, Span::Artificial)
     }
@@ -147,9 +168,7 @@ impl Value {
     pub(crate) fn from_builtin_env(b: Builtin, env: &NzEnv) -> Self {
         Value::from_kind_and_type(
             ValueKind::from_builtin_env(b, env.clone()),
-            crate::semantics::tck::typecheck::typecheck(&type_of_builtin(b))
-                .unwrap()
-                .normalize_whnf_noenv(),
+            typecheck(&type_of_builtin(b)).unwrap().eval_closed_expr(),
         )
     }
 
@@ -325,6 +344,7 @@ impl Value {
                     v.to_tyexpr(venv),
                 ))
             }
+            ValueKind::Thunk(th) => return th.to_tyexpr(venv),
             self_kind => {
                 let self_kind = self_kind.map_ref(|v| v.to_tyexpr(venv));
                 let expr = match self_kind {
@@ -333,7 +353,8 @@ impl Value {
                     | ValueKind::PiClosure { .. }
                     | ValueKind::AppliedBuiltin(..)
                     | ValueKind::UnionConstructor(..)
-                    | ValueKind::UnionLit(..) => unreachable!(),
+                    | ValueKind::UnionLit(..)
+                    | ValueKind::Thunk(..) => unreachable!(),
                     ValueKind::Const(c) => ExprKind::Const(c),
                     ValueKind::BoolLit(b) => ExprKind::BoolLit(b),
                     ValueKind::NaturalLit(n) => ExprKind::NaturalLit(n),
@@ -501,6 +522,9 @@ impl ValueKind<Value> {
             ValueKind::PartialExpr(e) => {
                 e.map_mut(Value::normalize_mut);
             }
+            ValueKind::Thunk(..) => {
+                unreachable!("Should only normalize_mut values in WHNF")
+            }
         }
     }
 
@@ -553,6 +577,22 @@ impl<V> ValueKind<V> {
     }
 }
 
+impl Thunk {
+    pub fn new(env: &NzEnv, body: TyExpr) -> Self {
+        Thunk {
+            env: env.clone(),
+            body,
+        }
+    }
+
+    pub fn eval(&self) -> Value {
+        normalize_tyexpr_whnf(&self.body, &self.env)
+    }
+    pub fn to_tyexpr(&self, venv: VarEnv) -> TyExpr {
+        self.eval().to_tyexpr(venv)
+    }
+}
+
 impl Closure {
     pub fn new(arg_ty: Value, env: &NzEnv, body: TyExpr) -> Self {
         Closure::Closure {
@@ -572,11 +612,9 @@ impl Closure {
     pub fn apply(&self, val: Value) -> Value {
         match self {
             Closure::Closure { env, body, .. } => {
-                body.normalize_whnf(&env.insert_value(val))
-            }
-            Closure::ConstantClosure { env, body, .. } => {
-                body.normalize_whnf(env)
+                body.eval(&env.insert_value(val))
             }
+            Closure::ConstantClosure { env, body, .. } => body.eval(env),
         }
     }
     fn apply_var(&self, var: NzVar) -> Value {
@@ -588,9 +626,7 @@ impl Closure {
                 );
                 self.apply(val)
             }
-            Closure::ConstantClosure { env, body, .. } => {
-                body.normalize_whnf(env)
-            }
+            Closure::ConstantClosure { env, body, .. } => body.eval(env),
         }
     }
 
@@ -626,6 +662,15 @@ impl std::cmp::PartialEq for Value {
 }
 impl std::cmp::Eq for Value {}
 
+impl std::cmp::PartialEq for Thunk {
+    fn eq(&self, _other: &Self) -> bool {
+        unreachable!(
+            "Trying to compare thunks but we should only compare WHNFs"
+        )
+    }
+}
+impl std::cmp::Eq for Thunk {}
+
 impl std::cmp::PartialEq for Closure {
     fn eq(&self, other: &Self) -> bool {
         let v = NzVar::fresh();
diff --git a/dhall/src/semantics/core/visitor.rs b/dhall/src/semantics/core/visitor.rs
index a78c219..d1a85d8 100644
--- a/dhall/src/semantics/core/visitor.rs
+++ b/dhall/src/semantics/core/visitor.rs
@@ -133,6 +133,7 @@ where
         ),
         Equivalence(x, y) => Equivalence(v.visit_val(x)?, v.visit_val(y)?),
         PartialExpr(e) => PartialExpr(e.traverse_ref(|e| v.visit_val(e))?),
+        Thunk(th) => Thunk(th.clone()),
     })
 }
 
diff --git a/dhall/src/semantics/phase/mod.rs b/dhall/src/semantics/phase/mod.rs
index f24a668..a25f096 100644
--- a/dhall/src/semantics/phase/mod.rs
+++ b/dhall/src/semantics/phase/mod.rs
@@ -91,7 +91,7 @@ impl Resolved {
 impl Typed {
     /// Reduce an expression to its normal form, performing beta reduction
     pub fn normalize(&self) -> Normalized {
-        Normalized(self.0.normalize_nf_noenv())
+        Normalized(self.0.rec_eval_closed_expr())
     }
 
     /// Converts a value back to the corresponding AST expression.
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index f36ec4a..ea1a25b 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -457,6 +457,7 @@ pub(crate) fn normalize_whnf(
     match v {
         ValueKind::AppliedBuiltin(closure) => closure.ensure_whnf(ty),
         ValueKind::PartialExpr(e) => normalize_one_layer(e, ty, &NzEnv::new()),
+        ValueKind::Thunk(th) => th.eval().kind().clone(),
         ValueKind::TextLit(elts) => {
             ValueKind::TextLit(squash_textlit(elts.into_iter()))
         }
@@ -475,7 +476,7 @@ pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> Value {
     let kind = match tye.kind() {
         TyExprKind::Var(var) => return env.lookup_val(var),
         TyExprKind::Expr(ExprKind::Lam(binder, annot, body)) => {
-            let annot = annot.normalize_whnf(env);
+            let annot = annot.eval(env);
             ValueKind::LamClosure {
                 binder: Binder::new(binder.clone()),
                 annot: annot.clone(),
@@ -483,7 +484,7 @@ pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> Value {
             }
         }
         TyExprKind::Expr(ExprKind::Pi(binder, annot, body)) => {
-            let annot = annot.normalize_whnf(env);
+            let annot = annot.eval(env);
             let closure = Closure::new(annot.clone(), env, body.clone());
             ValueKind::PiClosure {
                 binder: Binder::new(binder.clone()),
@@ -492,11 +493,11 @@ pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> Value {
             }
         }
         TyExprKind::Expr(ExprKind::Let(_, None, val, body)) => {
-            let val = val.normalize_whnf(env);
-            return body.normalize_whnf(&env.insert_value(val));
+            let val = val.eval(env);
+            return body.eval(&env.insert_value(val));
         }
         TyExprKind::Expr(e) => {
-            let e = e.map_ref(|tye| tye.normalize_whnf(env));
+            let e = e.map_ref(|tye| tye.eval(env));
             normalize_one_layer(e, &ty, env)
         }
     };
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index 5492b8b..0a27f32 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -49,6 +49,9 @@ impl TyExpr {
     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()),
@@ -69,17 +72,18 @@ impl TyExpr {
         tyexpr_to_expr(self, opts, &mut env)
     }
 
-    pub fn normalize_whnf(&self, env: &NzEnv) -> Value {
-        normalize_tyexpr_whnf(self, env)
-    }
-    pub fn normalize_whnf_noenv(&self) -> Value {
-        self.normalize_whnf(&NzEnv::new())
+    /// 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())
     }
-    pub fn normalize_nf(&self, env: &NzEnv) -> Value {
-        self.normalize_whnf(env)
+    /// 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())
     }
-    pub fn normalize_nf_noenv(&self) -> Value {
-        self.normalize_nf(&NzEnv::new())
+    /// Eval a closed TyExpr fully and recursively;
+    pub fn rec_eval_closed_expr(&self) -> Value {
+        normalize_tyexpr_whnf(self, &NzEnv::new())
     }
 }
 
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index bc1c87f..d741b40 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -74,7 +74,7 @@ fn type_one_layer(
         ExprKind::Builtin(b) => {
             let t_expr = type_of_builtin(*b);
             let t_tyexpr = type_with(env, &t_expr)?;
-            t_tyexpr.normalize_whnf(env.as_nzenv())
+            t_tyexpr.eval(env.as_nzenv())
         }
         ExprKind::BoolLit(_) => Value::from_builtin(Builtin::Bool),
         ExprKind::NaturalLit(_) => Value::from_builtin(Builtin::Natural),
@@ -93,7 +93,7 @@ fn type_one_layer(
             text_type
         }
         ExprKind::EmptyListLit(t) => {
-            let t = t.normalize_nf(env.as_nzenv());
+            let t = t.eval(env.as_nzenv());
             match &*t.kind() {
                 ValueKind::AppliedBuiltin(BuiltinClosure {
                     b: Builtin::List,
@@ -196,7 +196,7 @@ fn type_one_layer(
                 },
                 // TODO: branch here only when scrut.get_type() is a Const
                 _ => {
-                    let scrut_nf = scrut.normalize_nf(env.as_nzenv());
+                    let scrut_nf = scrut.eval(env.as_nzenv());
                     let scrut_nf_borrow = scrut_nf.kind();
                     match &*scrut_nf_borrow {
                         ValueKind::UnionType(kts) => match kts.get(x) {
@@ -224,7 +224,7 @@ fn type_one_layer(
             }
         }
         ExprKind::Annot(x, t) => {
-            let t = t.normalize_whnf(env.as_nzenv());
+            let t = t.eval(env.as_nzenv());
             let x_ty = x.get_type()?;
             if x_ty != t {
                 return mkerr(format!(
@@ -243,7 +243,7 @@ fn type_one_layer(
             x_ty
         }
         ExprKind::Assert(t) => {
-            let t = t.normalize_whnf(env.as_nzenv());
+            let t = t.eval(env.as_nzenv());
             match &*t.kind() {
                 ValueKind::Equivalence(x, y) if x == y => {}
                 ValueKind::Equivalence(..) => return mkerr("AssertMismatch"),
@@ -268,7 +268,7 @@ fn type_one_layer(
                         ));
                     }
 
-                    let arg_nf = arg.normalize_nf(env.as_nzenv());
+                    let arg_nf = arg.eval(env.as_nzenv());
                     closure.apply(arg_nf)
                 }
                 _ => return mkerr(format!("apply to not Pi")),
@@ -329,11 +329,11 @@ fn type_one_layer(
             );
             let ty = type_one_layer(env, &ekind)?;
             TyExpr::new(TyExprKind::Expr(ekind), Some(ty), Span::Artificial)
-                .normalize_nf(env.as_nzenv())
+                .eval(env.as_nzenv())
         }
         ExprKind::BinOp(BinOp::RecursiveRecordTypeMerge, x, y) => {
-            let x_val = x.normalize_whnf(env.as_nzenv());
-            let y_val = y.normalize_whnf(env.as_nzenv());
+            let x_val = x.eval(env.as_nzenv());
+            let y_val = y.eval(env.as_nzenv());
             let x_val_borrow = x_val.kind();
             let y_val_borrow = y_val.kind();
             let kts_x = match &*x_val_borrow {
@@ -478,9 +478,8 @@ fn type_one_layer(
                 }
             }
 
-            let type_annot = type_annot
-                .as_ref()
-                .map(|t| t.normalize_whnf(env.as_nzenv()));
+            let type_annot =
+                type_annot.as_ref().map(|t| t.eval(env.as_nzenv()));
             match (inferred_type, type_annot) {
                 (Some(t1), Some(t2)) => {
                     if t1 != t2 {
@@ -542,7 +541,7 @@ pub(crate) fn type_with(
         },
         ExprKind::Lam(binder, annot, body) => {
             let annot = type_with(env, annot)?;
-            let annot_nf = annot.normalize_nf(env.as_nzenv());
+            let annot_nf = annot.eval(env.as_nzenv());
             let body_env = env.insert_type(&binder, annot_nf.clone());
             let body = type_with(&body_env, body)?;
             let body_ty = body.get_type()?;
@@ -555,7 +554,7 @@ pub(crate) fn type_with(
                 Some(type_of_function(annot.get_type()?, body_ty.get_type()?)?),
                 Span::Artificial,
             );
-            let ty = ty.normalize_whnf(env.as_nzenv());
+            let ty = ty.eval(env.as_nzenv());
             (
                 TyExprKind::Expr(ExprKind::Lam(binder.clone(), annot, body)),
                 Some(ty),
@@ -563,7 +562,7 @@ pub(crate) fn type_with(
         }
         ExprKind::Pi(binder, annot, body) => {
             let annot = type_with(env, annot)?;
-            let annot_nf = annot.normalize_whnf(env.as_nzenv());
+            let annot_nf = annot.eval(env.as_nzenv());
             let body =
                 type_with(&env.insert_type(binder, annot_nf.clone()), body)?;
             let ty = type_of_function(annot.get_type()?, body.get_type()?)?;
@@ -580,7 +579,7 @@ pub(crate) fn type_with(
             };
 
             let val = type_with(env, &val)?;
-            let val_nf = val.normalize_nf(&env.as_nzenv());
+            let val_nf = val.eval(&env.as_nzenv());
             let body = type_with(&env.insert_value(&binder, val_nf), body)?;
             let body_ty = body.get_type().ok();
             (
-- 
cgit v1.2.3


From 0c95dd4f940e796865976dad594068ae0fff8f7c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 17:01:36 +0000
Subject: Move Value-related stuff under semantics::nze

---
 dhall/src/error/mod.rs              |   2 +-
 dhall/src/semantics/core/context.rs |   1 -
 dhall/src/semantics/core/mod.rs     |   6 -
 dhall/src/semantics/core/value.rs   | 698 ------------------------------------
 dhall/src/semantics/core/var.rs     |  36 --
 dhall/src/semantics/core/visitor.rs | 167 ---------
 dhall/src/semantics/mod.rs          |   2 -
 dhall/src/semantics/nze/mod.rs      |   5 +
 dhall/src/semantics/nze/value.rs    | 698 ++++++++++++++++++++++++++++++++++++
 dhall/src/semantics/nze/var.rs      |  36 ++
 dhall/src/semantics/nze/visitor.rs  | 167 +++++++++
 11 files changed, 907 insertions(+), 911 deletions(-)
 delete mode 100644 dhall/src/semantics/core/context.rs
 delete mode 100644 dhall/src/semantics/core/mod.rs
 delete mode 100644 dhall/src/semantics/core/value.rs
 delete mode 100644 dhall/src/semantics/core/var.rs
 delete mode 100644 dhall/src/semantics/core/visitor.rs
 create mode 100644 dhall/src/semantics/nze/value.rs
 create mode 100644 dhall/src/semantics/nze/var.rs
 create mode 100644 dhall/src/semantics/nze/visitor.rs

(limited to 'dhall')

diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index 215a7bf..852e795 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -1,8 +1,8 @@
 use std::io::Error as IOError;
 
-use crate::semantics::core::value::Value;
 use crate::semantics::phase::resolve::ImportStack;
 use crate::semantics::phase::NormalizedExpr;
+use crate::semantics::Value;
 use crate::syntax::{Import, ParseError};
 
 pub type Result<T> = std::result::Result<T, Error>;
diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
deleted file mode 100644
index 8b13789..0000000
--- a/dhall/src/semantics/core/context.rs
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/dhall/src/semantics/core/mod.rs b/dhall/src/semantics/core/mod.rs
deleted file mode 100644
index 6f577f0..0000000
--- a/dhall/src/semantics/core/mod.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-pub mod context;
-pub mod value;
-pub mod var;
-pub mod visitor;
-pub(crate) use value::*;
-pub(crate) use var::*;
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
deleted file mode 100644
index c881a9a..0000000
--- a/dhall/src/semantics/core/value.rs
+++ /dev/null
@@ -1,698 +0,0 @@
-use std::cell::{Ref, RefCell, RefMut};
-use std::collections::HashMap;
-use std::rc::Rc;
-
-use crate::error::{TypeError, TypeMessage};
-use crate::semantics::core::var::Binder;
-use crate::semantics::phase::normalize::{
-    apply_any, normalize_tyexpr_whnf, normalize_whnf,
-};
-use crate::semantics::phase::{Normalized, NormalizedExpr, ToExprOptions};
-use crate::semantics::{type_of_builtin, typecheck, TyExpr, TyExprKind};
-use crate::semantics::{BuiltinClosure, NzEnv, NzVar, VarEnv};
-use crate::syntax::{
-    BinOp, Builtin, Const, ExprKind, Integer, InterpolatedTextContents, Label,
-    NaiveDouble, Natural, Span,
-};
-
-use self::Form::{Unevaled, WHNF};
-
-/// Stores a possibly unevaluated value. Gets (partially) normalized on-demand, sharing computation
-/// automatically. Uses a RefCell to share computation.
-/// Can optionally store a type from typechecking to preserve type information.
-/// If you compare for equality two `Value`s in WHNF, then equality will be up to alpha-equivalence
-/// (renaming of bound variables) and beta-equivalence (normalization). It will recursively
-/// normalize as needed.
-#[derive(Clone)]
-pub(crate) struct Value(Rc<RefCell<ValueInternal>>);
-
-/// Invariant: if `form` is `WHNF`, `value` must be in Weak Head Normal Form
-#[derive(Debug)]
-struct ValueInternal {
-    form: Form,
-    kind: ValueKind<Value>,
-    /// This is None if and only if `value` is `Sort` (which doesn't have a type)
-    ty: Option<Value>,
-    span: Span,
-}
-
-#[derive(Debug, Clone, Copy)]
-pub(crate) enum Form {
-    /// No constraints; expression may not be normalized at all.
-    Unevaled,
-    /// Weak Head Normal Form, i.e. normalized up to the first constructor, but subexpressions may
-    /// not be normalized. This means that the first constructor of the contained ValueKind is the first
-    /// constructor of the final Normal Form (NF).
-    /// When all the Values in a ValueKind are in WHNF, and recursively so, then the
-    /// ValueKind is in NF. This is because WHNF ensures that we have the first constructor of the NF; so
-    /// if we have the first constructor of the NF at all levels, we actually have the NF.
-    WHNF,
-}
-
-/// An unevaluated subexpression
-#[derive(Debug, Clone)]
-pub(crate) struct Thunk {
-    env: NzEnv,
-    body: TyExpr,
-}
-
-/// An unevaluated subexpression that takes an argument.
-#[derive(Debug, Clone)]
-pub(crate) enum Closure {
-    /// Normal closure
-    Closure {
-        arg_ty: Value,
-        env: NzEnv,
-        body: TyExpr,
-    },
-    /// Closure that ignores the argument passed
-    ConstantClosure { env: NzEnv, body: TyExpr },
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) enum ValueKind<Value> {
-    /// Closures
-    LamClosure {
-        binder: Binder,
-        annot: Value,
-        closure: Closure,
-    },
-    PiClosure {
-        binder: Binder,
-        annot: Value,
-        closure: Closure,
-    },
-    // Invariant: in whnf, the evaluation must not be able to progress further.
-    AppliedBuiltin(BuiltinClosure<Value>),
-
-    Var(NzVar),
-    Const(Const),
-    BoolLit(bool),
-    NaturalLit(Natural),
-    IntegerLit(Integer),
-    DoubleLit(NaiveDouble),
-    EmptyOptionalLit(Value),
-    NEOptionalLit(Value),
-    // EmptyListLit(t) means `[] : List t`, not `[] : t`
-    EmptyListLit(Value),
-    NEListLit(Vec<Value>),
-    RecordType(HashMap<Label, Value>),
-    RecordLit(HashMap<Label, Value>),
-    UnionType(HashMap<Label, Option<Value>>),
-    // Also keep the type of the uniontype around
-    UnionConstructor(Label, HashMap<Label, Option<Value>>, Value),
-    // Also keep the type of the uniontype and the constructor around
-    UnionLit(Label, Value, HashMap<Label, Option<Value>>, Value, Value),
-    // Invariant: in whnf, this must not contain interpolations that are themselves TextLits, and
-    // contiguous text values must be merged.
-    TextLit(Vec<InterpolatedTextContents<Value>>),
-    Equivalence(Value, Value),
-    // Invariant: in whnf, this must not contain a value captured by one of the variants above.
-    PartialExpr(ExprKind<Value, Normalized>),
-    // Invariant: absent in whnf
-    Thunk(Thunk),
-}
-
-impl Value {
-    fn new(kind: ValueKind<Value>, form: Form, ty: Value, span: Span) -> Value {
-        ValueInternal {
-            form,
-            kind,
-            ty: Some(ty),
-            span,
-        }
-        .into_value()
-    }
-    pub(crate) fn const_sort() -> Value {
-        ValueInternal {
-            form: WHNF,
-            kind: ValueKind::Const(Const::Sort),
-            ty: None,
-            span: Span::Artificial,
-        }
-        .into_value()
-    }
-    pub(crate) fn new_thunk(env: &NzEnv, tye: TyExpr) -> Value {
-        ValueInternal {
-            form: Unevaled,
-            kind: ValueKind::Thunk(Thunk::new(env, tye.clone())),
-            ty: tye.get_type().ok(),
-            span: tye.span().clone(),
-        }
-        .into_value()
-    }
-    pub(crate) fn from_kind_and_type(v: ValueKind<Value>, t: Value) -> Value {
-        Value::new(v, Unevaled, t, Span::Artificial)
-    }
-    pub(crate) fn from_kind_and_type_whnf(
-        v: ValueKind<Value>,
-        t: Value,
-    ) -> Value {
-        Value::new(v, WHNF, t, Span::Artificial)
-    }
-    pub(crate) fn from_const(c: Const) -> Self {
-        let v = ValueKind::Const(c);
-        match c {
-            Const::Type => {
-                Value::from_kind_and_type(v, Value::from_const(Const::Kind))
-            }
-            Const::Kind => {
-                Value::from_kind_and_type(v, Value::from_const(Const::Sort))
-            }
-            Const::Sort => Value::const_sort(),
-        }
-    }
-    pub(crate) fn from_builtin(b: Builtin) -> Self {
-        Self::from_builtin_env(b, &NzEnv::new())
-    }
-    pub(crate) fn from_builtin_env(b: Builtin, env: &NzEnv) -> Self {
-        Value::from_kind_and_type(
-            ValueKind::from_builtin_env(b, env.clone()),
-            typecheck(&type_of_builtin(b)).unwrap().eval_closed_expr(),
-        )
-    }
-
-    pub(crate) fn as_const(&self) -> Option<Const> {
-        match &*self.kind() {
-            ValueKind::Const(c) => Some(*c),
-            _ => None,
-        }
-    }
-    pub(crate) fn span(&self) -> Span {
-        self.as_internal().span.clone()
-    }
-
-    fn as_internal(&self) -> Ref<ValueInternal> {
-        self.0.borrow()
-    }
-    fn as_internal_mut(&self) -> RefMut<ValueInternal> {
-        self.0.borrow_mut()
-    }
-    /// This is what you want if you want to pattern-match on the value.
-    /// WARNING: drop this ref before normalizing the same value or you will run into BorrowMut
-    /// panics.
-    pub(crate) fn kind(&self) -> Ref<ValueKind<Value>> {
-        self.normalize_whnf();
-        Ref::map(self.as_internal(), ValueInternal::as_kind)
-    }
-
-    /// Converts a value back to the corresponding AST expression.
-    pub(crate) fn to_expr(&self, opts: ToExprOptions) -> NormalizedExpr {
-        if opts.normalize {
-            self.normalize_nf();
-        }
-
-        self.to_tyexpr_noenv().to_expr(opts)
-    }
-    pub(crate) fn to_whnf_ignore_type(&self) -> ValueKind<Value> {
-        self.kind().clone()
-    }
-    /// Before discarding type information, check that it matches the expected return type.
-    pub(crate) fn to_whnf_check_type(&self, ty: &Value) -> ValueKind<Value> {
-        self.check_type(ty);
-        self.to_whnf_ignore_type()
-    }
-
-    /// Mutates the contents. If no one else shares this, this avoids a RefCell lock.
-    fn mutate_internal(&mut self, f: impl FnOnce(&mut ValueInternal)) {
-        match Rc::get_mut(&mut self.0) {
-            // Mutate directly if sole owner
-            Some(refcell) => f(RefCell::get_mut(refcell)),
-            // Otherwise mutate through the refcell
-            None => f(&mut self.as_internal_mut()),
-        }
-    }
-    /// Normalizes contents to normal form; faster than `normalize_nf` if
-    /// no one else shares this.
-    pub(crate) fn normalize_mut(&mut self) {
-        self.mutate_internal(|vint| vint.normalize_nf())
-    }
-
-    pub(crate) fn normalize_whnf(&self) {
-        let borrow = self.as_internal();
-        match borrow.form {
-            Unevaled => {
-                drop(borrow);
-                self.as_internal_mut().normalize_whnf();
-            }
-            // Already in WHNF
-            WHNF => {}
-        }
-    }
-    pub(crate) fn normalize_nf(&self) {
-        self.as_internal_mut().normalize_nf();
-    }
-
-    pub(crate) fn app(&self, v: Value) -> Value {
-        let body_t = match &*self.get_type_not_sort().kind() {
-            ValueKind::PiClosure { annot, closure, .. } => {
-                v.check_type(annot);
-                closure.apply(v.clone())
-            }
-            _ => unreachable!("Internal type error"),
-        };
-        Value::from_kind_and_type_whnf(
-            apply_any(self.clone(), v, &body_t),
-            body_t,
-        )
-    }
-
-    /// In debug mode, panic if the provided type doesn't match the value's type.
-    /// Otherwise does nothing.
-    pub(crate) fn check_type(&self, _ty: &Value) {
-        // TODO: reenable
-        // debug_assert_eq!(
-        //     Some(ty),
-        //     self.get_type().ok().as_ref(),
-        //     "Internal type error"
-        // );
-    }
-    pub(crate) fn get_type(&self) -> Result<Value, TypeError> {
-        Ok(self.as_internal().get_type()?.clone())
-    }
-    /// When we know the value isn't `Sort`, this gets the type directly
-    pub(crate) fn get_type_not_sort(&self) -> Value {
-        self.get_type()
-            .expect("Internal type error: value is `Sort` but shouldn't be")
-    }
-
-    pub fn to_tyexpr(&self, venv: VarEnv) -> TyExpr {
-        let tye = match &*self.kind() {
-            ValueKind::Var(v) => TyExprKind::Var(venv.lookup(v)),
-            ValueKind::LamClosure {
-                binder,
-                annot,
-                closure,
-            } => TyExprKind::Expr(ExprKind::Lam(
-                binder.to_label(),
-                annot.to_tyexpr(venv),
-                closure.to_tyexpr(venv),
-            )),
-            ValueKind::PiClosure {
-                binder,
-                annot,
-                closure,
-            } => TyExprKind::Expr(ExprKind::Pi(
-                binder.to_label(),
-                annot.to_tyexpr(venv),
-                closure.to_tyexpr(venv),
-            )),
-            ValueKind::AppliedBuiltin(closure) => closure.to_tyexprkind(venv),
-            ValueKind::UnionConstructor(l, kts, t) => {
-                TyExprKind::Expr(ExprKind::Field(
-                    TyExpr::new(
-                        TyExprKind::Expr(ExprKind::UnionType(
-                            kts.into_iter()
-                                .map(|(k, v)| {
-                                    (
-                                        k.clone(),
-                                        v.as_ref().map(|v| v.to_tyexpr(venv)),
-                                    )
-                                })
-                                .collect(),
-                        )),
-                        Some(t.clone()),
-                        Span::Artificial,
-                    ),
-                    l.clone(),
-                ))
-            }
-            ValueKind::UnionLit(l, v, kts, uniont, ctort) => {
-                TyExprKind::Expr(ExprKind::App(
-                    TyExpr::new(
-                        TyExprKind::Expr(ExprKind::Field(
-                            TyExpr::new(
-                                TyExprKind::Expr(ExprKind::UnionType(
-                                    kts.into_iter()
-                                        .map(|(k, v)| {
-                                            (
-                                                k.clone(),
-                                                v.as_ref()
-                                                    .map(|v| v.to_tyexpr(venv)),
-                                            )
-                                        })
-                                        .collect(),
-                                )),
-                                Some(uniont.clone()),
-                                Span::Artificial,
-                            ),
-                            l.clone(),
-                        )),
-                        Some(ctort.clone()),
-                        Span::Artificial,
-                    ),
-                    v.to_tyexpr(venv),
-                ))
-            }
-            ValueKind::Thunk(th) => return th.to_tyexpr(venv),
-            self_kind => {
-                let self_kind = self_kind.map_ref(|v| v.to_tyexpr(venv));
-                let expr = match self_kind {
-                    ValueKind::Var(..)
-                    | ValueKind::LamClosure { .. }
-                    | ValueKind::PiClosure { .. }
-                    | ValueKind::AppliedBuiltin(..)
-                    | ValueKind::UnionConstructor(..)
-                    | ValueKind::UnionLit(..)
-                    | ValueKind::Thunk(..) => unreachable!(),
-                    ValueKind::Const(c) => ExprKind::Const(c),
-                    ValueKind::BoolLit(b) => ExprKind::BoolLit(b),
-                    ValueKind::NaturalLit(n) => ExprKind::NaturalLit(n),
-                    ValueKind::IntegerLit(n) => ExprKind::IntegerLit(n),
-                    ValueKind::DoubleLit(n) => ExprKind::DoubleLit(n),
-                    ValueKind::EmptyOptionalLit(n) => ExprKind::App(
-                        Value::from_builtin(Builtin::OptionalNone)
-                            .to_tyexpr(venv),
-                        n,
-                    ),
-                    ValueKind::NEOptionalLit(n) => ExprKind::SomeLit(n),
-                    ValueKind::EmptyListLit(n) => {
-                        ExprKind::EmptyListLit(TyExpr::new(
-                            TyExprKind::Expr(ExprKind::App(
-                                Value::from_builtin(Builtin::List)
-                                    .to_tyexpr(venv),
-                                n,
-                            )),
-                            Some(Value::from_const(Const::Type)),
-                            Span::Artificial,
-                        ))
-                    }
-                    ValueKind::NEListLit(elts) => ExprKind::NEListLit(elts),
-                    ValueKind::RecordLit(kvs) => {
-                        ExprKind::RecordLit(kvs.into_iter().collect())
-                    }
-                    ValueKind::RecordType(kts) => {
-                        ExprKind::RecordType(kts.into_iter().collect())
-                    }
-                    ValueKind::UnionType(kts) => {
-                        ExprKind::UnionType(kts.into_iter().collect())
-                    }
-                    ValueKind::TextLit(elts) => {
-                        ExprKind::TextLit(elts.into_iter().collect())
-                    }
-                    ValueKind::Equivalence(x, y) => {
-                        ExprKind::BinOp(BinOp::Equivalence, x, y)
-                    }
-                    ValueKind::PartialExpr(e) => e,
-                };
-                TyExprKind::Expr(expr)
-            }
-        };
-
-        let self_ty = self.as_internal().ty.clone();
-        let self_span = self.as_internal().span.clone();
-        TyExpr::new(tye, self_ty, self_span)
-    }
-    pub fn to_tyexpr_noenv(&self) -> TyExpr {
-        self.to_tyexpr(VarEnv::new())
-    }
-}
-
-impl ValueInternal {
-    fn into_value(self) -> Value {
-        Value(Rc::new(RefCell::new(self)))
-    }
-    fn as_kind(&self) -> &ValueKind<Value> {
-        &self.kind
-    }
-
-    fn normalize_whnf(&mut self) {
-        let dummy = ValueInternal {
-            form: Unevaled,
-            kind: ValueKind::Const(Const::Type),
-            ty: None,
-            span: Span::Artificial,
-        };
-        let vint = std::mem::replace(self, dummy);
-        *self = match (&vint.form, &vint.ty) {
-            (Unevaled, Some(ty)) => ValueInternal {
-                form: WHNF,
-                kind: normalize_whnf(vint.kind, &ty),
-                ty: vint.ty,
-                span: vint.span,
-            },
-            // `value` is `Sort`
-            (Unevaled, None) => ValueInternal {
-                form: WHNF,
-                kind: ValueKind::Const(Const::Sort),
-                ty: None,
-                span: vint.span,
-            },
-            // Already in WHNF
-            (WHNF, _) => vint,
-        }
-    }
-    fn normalize_nf(&mut self) {
-        if let Unevaled = self.form {
-            self.normalize_whnf();
-        }
-        self.kind.normalize_mut();
-    }
-
-    fn get_type(&self) -> Result<&Value, TypeError> {
-        match &self.ty {
-            Some(t) => Ok(t),
-            None => Err(TypeError::new(TypeMessage::Sort)),
-        }
-    }
-}
-
-impl ValueKind<Value> {
-    pub(crate) fn into_value_with_type(self, t: Value) -> Value {
-        Value::from_kind_and_type(self, t)
-    }
-
-    pub(crate) fn normalize_mut(&mut self) {
-        match self {
-            ValueKind::Var(..)
-            | ValueKind::Const(_)
-            | ValueKind::BoolLit(_)
-            | ValueKind::NaturalLit(_)
-            | ValueKind::IntegerLit(_)
-            | ValueKind::DoubleLit(_) => {}
-
-            ValueKind::EmptyOptionalLit(tth) | ValueKind::EmptyListLit(tth) => {
-                tth.normalize_mut();
-            }
-
-            ValueKind::NEOptionalLit(th) => {
-                th.normalize_mut();
-            }
-            ValueKind::LamClosure { annot, .. }
-            | ValueKind::PiClosure { annot, .. } => {
-                annot.normalize_mut();
-            }
-            ValueKind::AppliedBuiltin(closure) => closure.normalize_mut(),
-            ValueKind::NEListLit(elts) => {
-                for x in elts.iter_mut() {
-                    x.normalize_mut();
-                }
-            }
-            ValueKind::RecordLit(kvs) => {
-                for x in kvs.values_mut() {
-                    x.normalize_mut();
-                }
-            }
-            ValueKind::RecordType(kvs) => {
-                for x in kvs.values_mut() {
-                    x.normalize_mut();
-                }
-            }
-            ValueKind::UnionType(kts)
-            | ValueKind::UnionConstructor(_, kts, _) => {
-                for x in kts.values_mut().flat_map(|opt| opt) {
-                    x.normalize_mut();
-                }
-            }
-            ValueKind::UnionLit(_, v, kts, _, _) => {
-                v.normalize_mut();
-                for x in kts.values_mut().flat_map(|opt| opt) {
-                    x.normalize_mut();
-                }
-            }
-            ValueKind::TextLit(elts) => {
-                for x in elts.iter_mut() {
-                    x.map_mut(Value::normalize_mut);
-                }
-            }
-            ValueKind::Equivalence(x, y) => {
-                x.normalize_mut();
-                y.normalize_mut();
-            }
-            ValueKind::PartialExpr(e) => {
-                e.map_mut(Value::normalize_mut);
-            }
-            ValueKind::Thunk(..) => {
-                unreachable!("Should only normalize_mut values in WHNF")
-            }
-        }
-    }
-
-    pub(crate) fn from_builtin(b: Builtin) -> ValueKind<Value> {
-        ValueKind::from_builtin_env(b, NzEnv::new())
-    }
-    pub(crate) fn from_builtin_env(b: Builtin, env: NzEnv) -> ValueKind<Value> {
-        ValueKind::AppliedBuiltin(BuiltinClosure::new(b, env))
-    }
-}
-
-impl<V> ValueKind<V> {
-    fn traverse_ref_with_special_handling_of_binders<'a, V2, E>(
-        &'a self,
-        visit_val: impl FnMut(&'a V) -> Result<V2, E>,
-        visit_under_binder: impl for<'b> FnMut(
-            &'a Binder,
-            &'b V,
-            &'a V,
-        ) -> Result<V2, E>,
-    ) -> Result<ValueKind<V2>, E> {
-        use crate::semantics::visitor;
-        use visitor::ValueKindVisitor;
-        visitor::TraverseRefWithBindersVisitor {
-            visit_val,
-            visit_under_binder,
-        }
-        .visit(self)
-    }
-
-    fn map_ref_with_special_handling_of_binders<'a, V2>(
-        &'a self,
-        mut map_val: impl FnMut(&'a V) -> V2,
-        mut map_under_binder: impl for<'b> FnMut(&'a Binder, &'b V, &'a V) -> V2,
-    ) -> ValueKind<V2> {
-        use crate::syntax::trivial_result;
-        trivial_result(self.traverse_ref_with_special_handling_of_binders(
-            |x| Ok(map_val(x)),
-            |l, t, x| Ok(map_under_binder(l, t, x)),
-        ))
-    }
-
-    fn map_ref<'a, V2>(
-        &'a self,
-        map_val: impl Fn(&'a V) -> V2,
-    ) -> ValueKind<V2> {
-        self.map_ref_with_special_handling_of_binders(&map_val, |_, _, x| {
-            map_val(x)
-        })
-    }
-}
-
-impl Thunk {
-    pub fn new(env: &NzEnv, body: TyExpr) -> Self {
-        Thunk {
-            env: env.clone(),
-            body,
-        }
-    }
-
-    pub fn eval(&self) -> Value {
-        normalize_tyexpr_whnf(&self.body, &self.env)
-    }
-    pub fn to_tyexpr(&self, venv: VarEnv) -> TyExpr {
-        self.eval().to_tyexpr(venv)
-    }
-}
-
-impl Closure {
-    pub fn new(arg_ty: Value, env: &NzEnv, body: TyExpr) -> Self {
-        Closure::Closure {
-            arg_ty,
-            env: env.clone(),
-            body,
-        }
-    }
-    /// New closure that ignores its argument
-    pub fn new_constant(env: &NzEnv, body: TyExpr) -> Self {
-        Closure::ConstantClosure {
-            env: env.clone(),
-            body,
-        }
-    }
-
-    pub fn apply(&self, val: Value) -> Value {
-        match self {
-            Closure::Closure { env, body, .. } => {
-                body.eval(&env.insert_value(val))
-            }
-            Closure::ConstantClosure { env, body, .. } => body.eval(env),
-        }
-    }
-    fn apply_var(&self, var: NzVar) -> Value {
-        match self {
-            Closure::Closure { arg_ty, .. } => {
-                let val = Value::from_kind_and_type(
-                    ValueKind::Var(var),
-                    arg_ty.clone(),
-                );
-                self.apply(val)
-            }
-            Closure::ConstantClosure { env, body, .. } => body.eval(env),
-        }
-    }
-
-    /// Convert this closure to a TyExpr
-    pub fn to_tyexpr(&self, venv: VarEnv) -> TyExpr {
-        self.apply_var(NzVar::new(venv.size()))
-            .to_tyexpr(venv.insert())
-    }
-    /// If the closure variable is free in the closure, return Err. Otherwise, return the value
-    /// with that free variable remove.
-    pub fn remove_binder(&self) -> Result<Value, ()> {
-        let v = NzVar::fresh();
-        match self {
-            Closure::Closure { .. } => {
-                // TODO: handle case where variable is used in closure
-                // TODO: return information about where the variable is used
-                Ok(self.apply_var(v))
-            }
-            Closure::ConstantClosure { .. } => {
-                // Ok: the variable is indeed ignored
-                Ok(self.apply_var(v))
-            }
-        }
-    }
-}
-
-/// Compare two values for equality modulo alpha/beta-equivalence.
-// TODO: use Rc comparison to shortcut on identical pointers
-impl std::cmp::PartialEq for Value {
-    fn eq(&self, other: &Self) -> bool {
-        *self.kind() == *other.kind()
-    }
-}
-impl std::cmp::Eq for Value {}
-
-impl std::cmp::PartialEq for Thunk {
-    fn eq(&self, _other: &Self) -> bool {
-        unreachable!(
-            "Trying to compare thunks but we should only compare WHNFs"
-        )
-    }
-}
-impl std::cmp::Eq for Thunk {}
-
-impl std::cmp::PartialEq for Closure {
-    fn eq(&self, other: &Self) -> bool {
-        let v = NzVar::fresh();
-        self.apply_var(v) == other.apply_var(v)
-    }
-}
-impl std::cmp::Eq for Closure {}
-
-impl std::fmt::Debug for Value {
-    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let vint: &ValueInternal = &self.as_internal();
-        if let ValueKind::Const(c) = &vint.kind {
-            write!(fmt, "{:?}", c)
-        } else {
-            let mut x = fmt.debug_struct(&format!("Value@{:?}", &vint.form));
-            x.field("value", &vint.kind);
-            if let Some(ty) = vint.ty.as_ref() {
-                x.field("type", &ty);
-            } else {
-                x.field("type", &None::<()>);
-            }
-            x.finish()
-        }
-    }
-}
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
deleted file mode 100644
index 264b81d..0000000
--- a/dhall/src/semantics/core/var.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use crate::syntax::Label;
-
-// Exactly like a Label, but equality returns always true.
-// This is so that ValueKind equality is exactly alpha-equivalence.
-#[derive(Clone, Eq)]
-pub struct Binder {
-    name: Label,
-}
-
-impl Binder {
-    pub(crate) fn new(name: Label) -> Self {
-        Binder { name }
-    }
-    pub(crate) fn to_label(&self) -> Label {
-        self.clone().into()
-    }
-}
-
-/// Equality up to alpha-equivalence
-impl std::cmp::PartialEq for Binder {
-    fn eq(&self, _other: &Self) -> bool {
-        true
-    }
-}
-
-impl std::fmt::Debug for Binder {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Binder({})", &self.name)
-    }
-}
-
-impl From<Binder> for Label {
-    fn from(x: Binder) -> Label {
-        x.name
-    }
-}
diff --git a/dhall/src/semantics/core/visitor.rs b/dhall/src/semantics/core/visitor.rs
deleted file mode 100644
index d1a85d8..0000000
--- a/dhall/src/semantics/core/visitor.rs
+++ /dev/null
@@ -1,167 +0,0 @@
-use std::iter::FromIterator;
-
-use crate::semantics::{Binder, BuiltinClosure, ValueKind};
-use crate::syntax::Label;
-
-/// A visitor trait that can be used to traverse `ValueKind`s. We need this pattern so that Rust lets
-/// us have as much mutability as we can. See the equivalent file in `crate::syntax` for more
-/// details.
-pub(crate) trait ValueKindVisitor<'a, V1, V2>: Sized {
-    type Error;
-
-    fn visit_val(&mut self, val: &'a V1) -> Result<V2, Self::Error>;
-    fn visit_binder(
-        mut self,
-        _label: &'a Binder,
-        ty: &'a V1,
-        val: &'a V1,
-    ) -> Result<(V2, V2), Self::Error> {
-        Ok((self.visit_val(ty)?, self.visit_val(val)?))
-    }
-    fn visit_vec(&mut self, x: &'a [V1]) -> Result<Vec<V2>, Self::Error> {
-        x.iter().map(|e| self.visit_val(e)).collect()
-    }
-    fn visit_opt(
-        &mut self,
-        x: &'a Option<V1>,
-    ) -> Result<Option<V2>, Self::Error> {
-        Ok(match x {
-            Some(x) => Some(self.visit_val(x)?),
-            None => None,
-        })
-    }
-    fn visit_map<T>(
-        &mut self,
-        x: impl IntoIterator<Item = (&'a Label, &'a V1)>,
-    ) -> Result<T, Self::Error>
-    where
-        V1: 'a,
-        T: FromIterator<(Label, V2)>,
-    {
-        x.into_iter()
-            .map(|(k, x)| Ok((k.clone(), self.visit_val(x)?)))
-            .collect()
-    }
-    fn visit_optmap<T>(
-        &mut self,
-        x: impl IntoIterator<Item = (&'a Label, &'a Option<V1>)>,
-    ) -> Result<T, Self::Error>
-    where
-        V1: 'a,
-        T: FromIterator<(Label, Option<V2>)>,
-    {
-        x.into_iter()
-            .map(|(k, x)| Ok((k.clone(), self.visit_opt(x)?)))
-            .collect()
-    }
-
-    fn visit(
-        self,
-        input: &'a ValueKind<V1>,
-    ) -> Result<ValueKind<V2>, Self::Error> {
-        visit_ref(self, input)
-    }
-}
-
-fn visit_ref<'a, Visitor, V1, V2>(
-    mut v: Visitor,
-    input: &'a ValueKind<V1>,
-) -> Result<ValueKind<V2>, Visitor::Error>
-where
-    Visitor: ValueKindVisitor<'a, V1, V2>,
-{
-    use ValueKind::*;
-    Ok(match input {
-        LamClosure {
-            binder,
-            annot,
-            closure,
-        } => LamClosure {
-            binder: binder.clone(),
-            annot: v.visit_val(annot)?,
-            closure: closure.clone(),
-        },
-        PiClosure {
-            binder,
-            annot,
-            closure,
-        } => PiClosure {
-            binder: binder.clone(),
-            annot: v.visit_val(annot)?,
-            closure: closure.clone(),
-        },
-        AppliedBuiltin(BuiltinClosure {
-            b,
-            args,
-            types,
-            env,
-        }) => AppliedBuiltin(BuiltinClosure {
-            b: *b,
-            args: v.visit_vec(args)?,
-            types: v.visit_vec(types)?,
-            env: env.clone(),
-        }),
-        Var(v) => Var(*v),
-        Const(k) => Const(*k),
-        BoolLit(b) => BoolLit(*b),
-        NaturalLit(n) => NaturalLit(*n),
-        IntegerLit(n) => IntegerLit(*n),
-        DoubleLit(n) => DoubleLit(*n),
-        EmptyOptionalLit(t) => EmptyOptionalLit(v.visit_val(t)?),
-        NEOptionalLit(x) => NEOptionalLit(v.visit_val(x)?),
-        EmptyListLit(t) => EmptyListLit(v.visit_val(t)?),
-        NEListLit(xs) => NEListLit(v.visit_vec(xs)?),
-        RecordType(kts) => RecordType(v.visit_map(kts)?),
-        RecordLit(kvs) => RecordLit(v.visit_map(kvs)?),
-        UnionType(kts) => UnionType(v.visit_optmap(kts)?),
-        UnionConstructor(l, kts, uniont) => UnionConstructor(
-            l.clone(),
-            v.visit_optmap(kts)?,
-            v.visit_val(uniont)?,
-        ),
-        UnionLit(l, x, kts, uniont, ctort) => UnionLit(
-            l.clone(),
-            v.visit_val(x)?,
-            v.visit_optmap(kts)?,
-            v.visit_val(uniont)?,
-            v.visit_val(ctort)?,
-        ),
-        TextLit(ts) => TextLit(
-            ts.iter()
-                .map(|t| t.traverse_ref(|e| v.visit_val(e)))
-                .collect::<Result<_, _>>()?,
-        ),
-        Equivalence(x, y) => Equivalence(v.visit_val(x)?, v.visit_val(y)?),
-        PartialExpr(e) => PartialExpr(e.traverse_ref(|e| v.visit_val(e))?),
-        Thunk(th) => Thunk(th.clone()),
-    })
-}
-
-pub struct TraverseRefWithBindersVisitor<F1, F2> {
-    pub visit_val: F1,
-    pub visit_under_binder: F2,
-}
-
-impl<'a, V1, V2, Err, F1, F2> ValueKindVisitor<'a, V1, V2>
-    for TraverseRefWithBindersVisitor<F1, F2>
-where
-    V1: 'a,
-    F1: FnMut(&'a V1) -> Result<V2, Err>,
-    F2: for<'b> FnOnce(&'a Binder, &'b V1, &'a V1) -> Result<V2, Err>,
-{
-    type Error = Err;
-
-    fn visit_val(&mut self, val: &'a V1) -> Result<V2, Self::Error> {
-        (self.visit_val)(val)
-    }
-    fn visit_binder<'b>(
-        mut self,
-        label: &'a Binder,
-        ty: &'a V1,
-        val: &'a V1,
-    ) -> Result<(V2, V2), Self::Error> {
-        let val = (self.visit_under_binder)(label, ty, val)?;
-        let ty = (self.visit_val)(ty)?;
-        Ok((ty, val))
-    }
-}
diff --git a/dhall/src/semantics/mod.rs b/dhall/src/semantics/mod.rs
index 01bbd39..92e5912 100644
--- a/dhall/src/semantics/mod.rs
+++ b/dhall/src/semantics/mod.rs
@@ -1,9 +1,7 @@
 pub mod builtins;
-pub mod core;
 pub mod nze;
 pub mod phase;
 pub mod tck;
 pub(crate) use self::builtins::*;
-pub(crate) use self::core::*;
 pub(crate) use self::nze::*;
 pub(crate) use self::tck::*;
diff --git a/dhall/src/semantics/nze/mod.rs b/dhall/src/semantics/nze/mod.rs
index 1cd2363..f367f8f 100644
--- a/dhall/src/semantics/nze/mod.rs
+++ b/dhall/src/semantics/nze/mod.rs
@@ -1,2 +1,7 @@
 pub mod env;
+pub mod value;
+pub mod var;
+pub mod visitor;
 pub(crate) use env::*;
+pub(crate) use value::*;
+pub(crate) use var::*;
diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
new file mode 100644
index 0000000..4960076
--- /dev/null
+++ b/dhall/src/semantics/nze/value.rs
@@ -0,0 +1,698 @@
+use std::cell::{Ref, RefCell, RefMut};
+use std::collections::HashMap;
+use std::rc::Rc;
+
+use crate::error::{TypeError, TypeMessage};
+use crate::semantics::nze::visitor;
+use crate::semantics::phase::normalize::{
+    apply_any, normalize_tyexpr_whnf, normalize_whnf,
+};
+use crate::semantics::phase::{Normalized, NormalizedExpr, ToExprOptions};
+use crate::semantics::Binder;
+use crate::semantics::{type_of_builtin, typecheck, TyExpr, TyExprKind};
+use crate::semantics::{BuiltinClosure, NzEnv, NzVar, VarEnv};
+use crate::syntax::{
+    BinOp, Builtin, Const, ExprKind, Integer, InterpolatedTextContents, Label,
+    NaiveDouble, Natural, Span,
+};
+
+use self::Form::{Unevaled, WHNF};
+
+/// Stores a possibly unevaluated value. Gets (partially) normalized on-demand, sharing computation
+/// automatically. Uses a RefCell to share computation.
+/// Can optionally store a type from typechecking to preserve type information.
+/// If you compare for equality two `Value`s in WHNF, then equality will be up to alpha-equivalence
+/// (renaming of bound variables) and beta-equivalence (normalization). It will recursively
+/// normalize as needed.
+#[derive(Clone)]
+pub(crate) struct Value(Rc<RefCell<ValueInternal>>);
+
+/// Invariant: if `form` is `WHNF`, `value` must be in Weak Head Normal Form
+#[derive(Debug)]
+struct ValueInternal {
+    form: Form,
+    kind: ValueKind<Value>,
+    /// This is None if and only if `value` is `Sort` (which doesn't have a type)
+    ty: Option<Value>,
+    span: Span,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum Form {
+    /// No constraints; expression may not be normalized at all.
+    Unevaled,
+    /// Weak Head Normal Form, i.e. normalized up to the first constructor, but subexpressions may
+    /// not be normalized. This means that the first constructor of the contained ValueKind is the first
+    /// constructor of the final Normal Form (NF).
+    /// When all the Values in a ValueKind are in WHNF, and recursively so, then the
+    /// ValueKind is in NF. This is because WHNF ensures that we have the first constructor of the NF; so
+    /// if we have the first constructor of the NF at all levels, we actually have the NF.
+    WHNF,
+}
+
+/// An unevaluated subexpression
+#[derive(Debug, Clone)]
+pub(crate) struct Thunk {
+    env: NzEnv,
+    body: TyExpr,
+}
+
+/// An unevaluated subexpression that takes an argument.
+#[derive(Debug, Clone)]
+pub(crate) enum Closure {
+    /// Normal closure
+    Closure {
+        arg_ty: Value,
+        env: NzEnv,
+        body: TyExpr,
+    },
+    /// Closure that ignores the argument passed
+    ConstantClosure { env: NzEnv, body: TyExpr },
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum ValueKind<Value> {
+    /// Closures
+    LamClosure {
+        binder: Binder,
+        annot: Value,
+        closure: Closure,
+    },
+    PiClosure {
+        binder: Binder,
+        annot: Value,
+        closure: Closure,
+    },
+    // Invariant: in whnf, the evaluation must not be able to progress further.
+    AppliedBuiltin(BuiltinClosure<Value>),
+
+    Var(NzVar),
+    Const(Const),
+    BoolLit(bool),
+    NaturalLit(Natural),
+    IntegerLit(Integer),
+    DoubleLit(NaiveDouble),
+    EmptyOptionalLit(Value),
+    NEOptionalLit(Value),
+    // EmptyListLit(t) means `[] : List t`, not `[] : t`
+    EmptyListLit(Value),
+    NEListLit(Vec<Value>),
+    RecordType(HashMap<Label, Value>),
+    RecordLit(HashMap<Label, Value>),
+    UnionType(HashMap<Label, Option<Value>>),
+    // Also keep the type of the uniontype around
+    UnionConstructor(Label, HashMap<Label, Option<Value>>, Value),
+    // Also keep the type of the uniontype and the constructor around
+    UnionLit(Label, Value, HashMap<Label, Option<Value>>, Value, Value),
+    // Invariant: in whnf, this must not contain interpolations that are themselves TextLits, and
+    // contiguous text values must be merged.
+    TextLit(Vec<InterpolatedTextContents<Value>>),
+    Equivalence(Value, Value),
+    // Invariant: in whnf, this must not contain a value captured by one of the variants above.
+    PartialExpr(ExprKind<Value, Normalized>),
+    // Invariant: absent in whnf
+    Thunk(Thunk),
+}
+
+impl Value {
+    fn new(kind: ValueKind<Value>, form: Form, ty: Value, span: Span) -> Value {
+        ValueInternal {
+            form,
+            kind,
+            ty: Some(ty),
+            span,
+        }
+        .into_value()
+    }
+    pub(crate) fn const_sort() -> Value {
+        ValueInternal {
+            form: WHNF,
+            kind: ValueKind::Const(Const::Sort),
+            ty: None,
+            span: Span::Artificial,
+        }
+        .into_value()
+    }
+    pub(crate) fn new_thunk(env: &NzEnv, tye: TyExpr) -> Value {
+        ValueInternal {
+            form: Unevaled,
+            kind: ValueKind::Thunk(Thunk::new(env, tye.clone())),
+            ty: tye.get_type().ok(),
+            span: tye.span().clone(),
+        }
+        .into_value()
+    }
+    pub(crate) fn from_kind_and_type(v: ValueKind<Value>, t: Value) -> Value {
+        Value::new(v, Unevaled, t, Span::Artificial)
+    }
+    pub(crate) fn from_kind_and_type_whnf(
+        v: ValueKind<Value>,
+        t: Value,
+    ) -> Value {
+        Value::new(v, WHNF, t, Span::Artificial)
+    }
+    pub(crate) fn from_const(c: Const) -> Self {
+        let v = ValueKind::Const(c);
+        match c {
+            Const::Type => {
+                Value::from_kind_and_type(v, Value::from_const(Const::Kind))
+            }
+            Const::Kind => {
+                Value::from_kind_and_type(v, Value::from_const(Const::Sort))
+            }
+            Const::Sort => Value::const_sort(),
+        }
+    }
+    pub(crate) fn from_builtin(b: Builtin) -> Self {
+        Self::from_builtin_env(b, &NzEnv::new())
+    }
+    pub(crate) fn from_builtin_env(b: Builtin, env: &NzEnv) -> Self {
+        Value::from_kind_and_type(
+            ValueKind::from_builtin_env(b, env.clone()),
+            typecheck(&type_of_builtin(b)).unwrap().eval_closed_expr(),
+        )
+    }
+
+    pub(crate) fn as_const(&self) -> Option<Const> {
+        match &*self.kind() {
+            ValueKind::Const(c) => Some(*c),
+            _ => None,
+        }
+    }
+    pub(crate) fn span(&self) -> Span {
+        self.as_internal().span.clone()
+    }
+
+    fn as_internal(&self) -> Ref<ValueInternal> {
+        self.0.borrow()
+    }
+    fn as_internal_mut(&self) -> RefMut<ValueInternal> {
+        self.0.borrow_mut()
+    }
+    /// This is what you want if you want to pattern-match on the value.
+    /// WARNING: drop this ref before normalizing the same value or you will run into BorrowMut
+    /// panics.
+    pub(crate) fn kind(&self) -> Ref<ValueKind<Value>> {
+        self.normalize_whnf();
+        Ref::map(self.as_internal(), ValueInternal::as_kind)
+    }
+
+    /// Converts a value back to the corresponding AST expression.
+    pub(crate) fn to_expr(&self, opts: ToExprOptions) -> NormalizedExpr {
+        if opts.normalize {
+            self.normalize_nf();
+        }
+
+        self.to_tyexpr_noenv().to_expr(opts)
+    }
+    pub(crate) fn to_whnf_ignore_type(&self) -> ValueKind<Value> {
+        self.kind().clone()
+    }
+    /// Before discarding type information, check that it matches the expected return type.
+    pub(crate) fn to_whnf_check_type(&self, ty: &Value) -> ValueKind<Value> {
+        self.check_type(ty);
+        self.to_whnf_ignore_type()
+    }
+
+    /// Mutates the contents. If no one else shares this, this avoids a RefCell lock.
+    fn mutate_internal(&mut self, f: impl FnOnce(&mut ValueInternal)) {
+        match Rc::get_mut(&mut self.0) {
+            // Mutate directly if sole owner
+            Some(refcell) => f(RefCell::get_mut(refcell)),
+            // Otherwise mutate through the refcell
+            None => f(&mut self.as_internal_mut()),
+        }
+    }
+    /// Normalizes contents to normal form; faster than `normalize_nf` if
+    /// no one else shares this.
+    pub(crate) fn normalize_mut(&mut self) {
+        self.mutate_internal(|vint| vint.normalize_nf())
+    }
+
+    pub(crate) fn normalize_whnf(&self) {
+        let borrow = self.as_internal();
+        match borrow.form {
+            Unevaled => {
+                drop(borrow);
+                self.as_internal_mut().normalize_whnf();
+            }
+            // Already in WHNF
+            WHNF => {}
+        }
+    }
+    pub(crate) fn normalize_nf(&self) {
+        self.as_internal_mut().normalize_nf();
+    }
+
+    pub(crate) fn app(&self, v: Value) -> Value {
+        let body_t = match &*self.get_type_not_sort().kind() {
+            ValueKind::PiClosure { annot, closure, .. } => {
+                v.check_type(annot);
+                closure.apply(v.clone())
+            }
+            _ => unreachable!("Internal type error"),
+        };
+        Value::from_kind_and_type_whnf(
+            apply_any(self.clone(), v, &body_t),
+            body_t,
+        )
+    }
+
+    /// In debug mode, panic if the provided type doesn't match the value's type.
+    /// Otherwise does nothing.
+    pub(crate) fn check_type(&self, _ty: &Value) {
+        // TODO: reenable
+        // debug_assert_eq!(
+        //     Some(ty),
+        //     self.get_type().ok().as_ref(),
+        //     "Internal type error"
+        // );
+    }
+    pub(crate) fn get_type(&self) -> Result<Value, TypeError> {
+        Ok(self.as_internal().get_type()?.clone())
+    }
+    /// When we know the value isn't `Sort`, this gets the type directly
+    pub(crate) fn get_type_not_sort(&self) -> Value {
+        self.get_type()
+            .expect("Internal type error: value is `Sort` but shouldn't be")
+    }
+
+    pub fn to_tyexpr(&self, venv: VarEnv) -> TyExpr {
+        let tye = match &*self.kind() {
+            ValueKind::Var(v) => TyExprKind::Var(venv.lookup(v)),
+            ValueKind::LamClosure {
+                binder,
+                annot,
+                closure,
+            } => TyExprKind::Expr(ExprKind::Lam(
+                binder.to_label(),
+                annot.to_tyexpr(venv),
+                closure.to_tyexpr(venv),
+            )),
+            ValueKind::PiClosure {
+                binder,
+                annot,
+                closure,
+            } => TyExprKind::Expr(ExprKind::Pi(
+                binder.to_label(),
+                annot.to_tyexpr(venv),
+                closure.to_tyexpr(venv),
+            )),
+            ValueKind::AppliedBuiltin(closure) => closure.to_tyexprkind(venv),
+            ValueKind::UnionConstructor(l, kts, t) => {
+                TyExprKind::Expr(ExprKind::Field(
+                    TyExpr::new(
+                        TyExprKind::Expr(ExprKind::UnionType(
+                            kts.into_iter()
+                                .map(|(k, v)| {
+                                    (
+                                        k.clone(),
+                                        v.as_ref().map(|v| v.to_tyexpr(venv)),
+                                    )
+                                })
+                                .collect(),
+                        )),
+                        Some(t.clone()),
+                        Span::Artificial,
+                    ),
+                    l.clone(),
+                ))
+            }
+            ValueKind::UnionLit(l, v, kts, uniont, ctort) => {
+                TyExprKind::Expr(ExprKind::App(
+                    TyExpr::new(
+                        TyExprKind::Expr(ExprKind::Field(
+                            TyExpr::new(
+                                TyExprKind::Expr(ExprKind::UnionType(
+                                    kts.into_iter()
+                                        .map(|(k, v)| {
+                                            (
+                                                k.clone(),
+                                                v.as_ref()
+                                                    .map(|v| v.to_tyexpr(venv)),
+                                            )
+                                        })
+                                        .collect(),
+                                )),
+                                Some(uniont.clone()),
+                                Span::Artificial,
+                            ),
+                            l.clone(),
+                        )),
+                        Some(ctort.clone()),
+                        Span::Artificial,
+                    ),
+                    v.to_tyexpr(venv),
+                ))
+            }
+            ValueKind::Thunk(th) => return th.to_tyexpr(venv),
+            self_kind => {
+                let self_kind = self_kind.map_ref(|v| v.to_tyexpr(venv));
+                let expr = match self_kind {
+                    ValueKind::Var(..)
+                    | ValueKind::LamClosure { .. }
+                    | ValueKind::PiClosure { .. }
+                    | ValueKind::AppliedBuiltin(..)
+                    | ValueKind::UnionConstructor(..)
+                    | ValueKind::UnionLit(..)
+                    | ValueKind::Thunk(..) => unreachable!(),
+                    ValueKind::Const(c) => ExprKind::Const(c),
+                    ValueKind::BoolLit(b) => ExprKind::BoolLit(b),
+                    ValueKind::NaturalLit(n) => ExprKind::NaturalLit(n),
+                    ValueKind::IntegerLit(n) => ExprKind::IntegerLit(n),
+                    ValueKind::DoubleLit(n) => ExprKind::DoubleLit(n),
+                    ValueKind::EmptyOptionalLit(n) => ExprKind::App(
+                        Value::from_builtin(Builtin::OptionalNone)
+                            .to_tyexpr(venv),
+                        n,
+                    ),
+                    ValueKind::NEOptionalLit(n) => ExprKind::SomeLit(n),
+                    ValueKind::EmptyListLit(n) => {
+                        ExprKind::EmptyListLit(TyExpr::new(
+                            TyExprKind::Expr(ExprKind::App(
+                                Value::from_builtin(Builtin::List)
+                                    .to_tyexpr(venv),
+                                n,
+                            )),
+                            Some(Value::from_const(Const::Type)),
+                            Span::Artificial,
+                        ))
+                    }
+                    ValueKind::NEListLit(elts) => ExprKind::NEListLit(elts),
+                    ValueKind::RecordLit(kvs) => {
+                        ExprKind::RecordLit(kvs.into_iter().collect())
+                    }
+                    ValueKind::RecordType(kts) => {
+                        ExprKind::RecordType(kts.into_iter().collect())
+                    }
+                    ValueKind::UnionType(kts) => {
+                        ExprKind::UnionType(kts.into_iter().collect())
+                    }
+                    ValueKind::TextLit(elts) => {
+                        ExprKind::TextLit(elts.into_iter().collect())
+                    }
+                    ValueKind::Equivalence(x, y) => {
+                        ExprKind::BinOp(BinOp::Equivalence, x, y)
+                    }
+                    ValueKind::PartialExpr(e) => e,
+                };
+                TyExprKind::Expr(expr)
+            }
+        };
+
+        let self_ty = self.as_internal().ty.clone();
+        let self_span = self.as_internal().span.clone();
+        TyExpr::new(tye, self_ty, self_span)
+    }
+    pub fn to_tyexpr_noenv(&self) -> TyExpr {
+        self.to_tyexpr(VarEnv::new())
+    }
+}
+
+impl ValueInternal {
+    fn into_value(self) -> Value {
+        Value(Rc::new(RefCell::new(self)))
+    }
+    fn as_kind(&self) -> &ValueKind<Value> {
+        &self.kind
+    }
+
+    fn normalize_whnf(&mut self) {
+        let dummy = ValueInternal {
+            form: Unevaled,
+            kind: ValueKind::Const(Const::Type),
+            ty: None,
+            span: Span::Artificial,
+        };
+        let vint = std::mem::replace(self, dummy);
+        *self = match (&vint.form, &vint.ty) {
+            (Unevaled, Some(ty)) => ValueInternal {
+                form: WHNF,
+                kind: normalize_whnf(vint.kind, &ty),
+                ty: vint.ty,
+                span: vint.span,
+            },
+            // `value` is `Sort`
+            (Unevaled, None) => ValueInternal {
+                form: WHNF,
+                kind: ValueKind::Const(Const::Sort),
+                ty: None,
+                span: vint.span,
+            },
+            // Already in WHNF
+            (WHNF, _) => vint,
+        }
+    }
+    fn normalize_nf(&mut self) {
+        if let Unevaled = self.form {
+            self.normalize_whnf();
+        }
+        self.kind.normalize_mut();
+    }
+
+    fn get_type(&self) -> Result<&Value, TypeError> {
+        match &self.ty {
+            Some(t) => Ok(t),
+            None => Err(TypeError::new(TypeMessage::Sort)),
+        }
+    }
+}
+
+impl ValueKind<Value> {
+    pub(crate) fn into_value_with_type(self, t: Value) -> Value {
+        Value::from_kind_and_type(self, t)
+    }
+
+    pub(crate) fn normalize_mut(&mut self) {
+        match self {
+            ValueKind::Var(..)
+            | ValueKind::Const(_)
+            | ValueKind::BoolLit(_)
+            | ValueKind::NaturalLit(_)
+            | ValueKind::IntegerLit(_)
+            | ValueKind::DoubleLit(_) => {}
+
+            ValueKind::EmptyOptionalLit(tth) | ValueKind::EmptyListLit(tth) => {
+                tth.normalize_mut();
+            }
+
+            ValueKind::NEOptionalLit(th) => {
+                th.normalize_mut();
+            }
+            ValueKind::LamClosure { annot, .. }
+            | ValueKind::PiClosure { annot, .. } => {
+                annot.normalize_mut();
+            }
+            ValueKind::AppliedBuiltin(closure) => closure.normalize_mut(),
+            ValueKind::NEListLit(elts) => {
+                for x in elts.iter_mut() {
+                    x.normalize_mut();
+                }
+            }
+            ValueKind::RecordLit(kvs) => {
+                for x in kvs.values_mut() {
+                    x.normalize_mut();
+                }
+            }
+            ValueKind::RecordType(kvs) => {
+                for x in kvs.values_mut() {
+                    x.normalize_mut();
+                }
+            }
+            ValueKind::UnionType(kts)
+            | ValueKind::UnionConstructor(_, kts, _) => {
+                for x in kts.values_mut().flat_map(|opt| opt) {
+                    x.normalize_mut();
+                }
+            }
+            ValueKind::UnionLit(_, v, kts, _, _) => {
+                v.normalize_mut();
+                for x in kts.values_mut().flat_map(|opt| opt) {
+                    x.normalize_mut();
+                }
+            }
+            ValueKind::TextLit(elts) => {
+                for x in elts.iter_mut() {
+                    x.map_mut(Value::normalize_mut);
+                }
+            }
+            ValueKind::Equivalence(x, y) => {
+                x.normalize_mut();
+                y.normalize_mut();
+            }
+            ValueKind::PartialExpr(e) => {
+                e.map_mut(Value::normalize_mut);
+            }
+            ValueKind::Thunk(..) => {
+                unreachable!("Should only normalize_mut values in WHNF")
+            }
+        }
+    }
+
+    pub(crate) fn from_builtin(b: Builtin) -> ValueKind<Value> {
+        ValueKind::from_builtin_env(b, NzEnv::new())
+    }
+    pub(crate) fn from_builtin_env(b: Builtin, env: NzEnv) -> ValueKind<Value> {
+        ValueKind::AppliedBuiltin(BuiltinClosure::new(b, env))
+    }
+}
+
+impl<V> ValueKind<V> {
+    fn traverse_ref_with_special_handling_of_binders<'a, V2, E>(
+        &'a self,
+        visit_val: impl FnMut(&'a V) -> Result<V2, E>,
+        visit_under_binder: impl for<'b> FnMut(
+            &'a Binder,
+            &'b V,
+            &'a V,
+        ) -> Result<V2, E>,
+    ) -> Result<ValueKind<V2>, E> {
+        use visitor::ValueKindVisitor;
+        visitor::TraverseRefWithBindersVisitor {
+            visit_val,
+            visit_under_binder,
+        }
+        .visit(self)
+    }
+
+    fn map_ref_with_special_handling_of_binders<'a, V2>(
+        &'a self,
+        mut map_val: impl FnMut(&'a V) -> V2,
+        mut map_under_binder: impl for<'b> FnMut(&'a Binder, &'b V, &'a V) -> V2,
+    ) -> ValueKind<V2> {
+        use crate::syntax::trivial_result;
+        trivial_result(self.traverse_ref_with_special_handling_of_binders(
+            |x| Ok(map_val(x)),
+            |l, t, x| Ok(map_under_binder(l, t, x)),
+        ))
+    }
+
+    fn map_ref<'a, V2>(
+        &'a self,
+        map_val: impl Fn(&'a V) -> V2,
+    ) -> ValueKind<V2> {
+        self.map_ref_with_special_handling_of_binders(&map_val, |_, _, x| {
+            map_val(x)
+        })
+    }
+}
+
+impl Thunk {
+    pub fn new(env: &NzEnv, body: TyExpr) -> Self {
+        Thunk {
+            env: env.clone(),
+            body,
+        }
+    }
+
+    pub fn eval(&self) -> Value {
+        normalize_tyexpr_whnf(&self.body, &self.env)
+    }
+    pub fn to_tyexpr(&self, venv: VarEnv) -> TyExpr {
+        self.eval().to_tyexpr(venv)
+    }
+}
+
+impl Closure {
+    pub fn new(arg_ty: Value, env: &NzEnv, body: TyExpr) -> Self {
+        Closure::Closure {
+            arg_ty,
+            env: env.clone(),
+            body,
+        }
+    }
+    /// New closure that ignores its argument
+    pub fn new_constant(env: &NzEnv, body: TyExpr) -> Self {
+        Closure::ConstantClosure {
+            env: env.clone(),
+            body,
+        }
+    }
+
+    pub fn apply(&self, val: Value) -> Value {
+        match self {
+            Closure::Closure { env, body, .. } => {
+                body.eval(&env.insert_value(val))
+            }
+            Closure::ConstantClosure { env, body, .. } => body.eval(env),
+        }
+    }
+    fn apply_var(&self, var: NzVar) -> Value {
+        match self {
+            Closure::Closure { arg_ty, .. } => {
+                let val = Value::from_kind_and_type(
+                    ValueKind::Var(var),
+                    arg_ty.clone(),
+                );
+                self.apply(val)
+            }
+            Closure::ConstantClosure { env, body, .. } => body.eval(env),
+        }
+    }
+
+    /// Convert this closure to a TyExpr
+    pub fn to_tyexpr(&self, venv: VarEnv) -> TyExpr {
+        self.apply_var(NzVar::new(venv.size()))
+            .to_tyexpr(venv.insert())
+    }
+    /// If the closure variable is free in the closure, return Err. Otherwise, return the value
+    /// with that free variable remove.
+    pub fn remove_binder(&self) -> Result<Value, ()> {
+        let v = NzVar::fresh();
+        match self {
+            Closure::Closure { .. } => {
+                // TODO: handle case where variable is used in closure
+                // TODO: return information about where the variable is used
+                Ok(self.apply_var(v))
+            }
+            Closure::ConstantClosure { .. } => {
+                // Ok: the variable is indeed ignored
+                Ok(self.apply_var(v))
+            }
+        }
+    }
+}
+
+/// Compare two values for equality modulo alpha/beta-equivalence.
+// TODO: use Rc comparison to shortcut on identical pointers
+impl std::cmp::PartialEq for Value {
+    fn eq(&self, other: &Self) -> bool {
+        *self.kind() == *other.kind()
+    }
+}
+impl std::cmp::Eq for Value {}
+
+impl std::cmp::PartialEq for Thunk {
+    fn eq(&self, _other: &Self) -> bool {
+        unreachable!(
+            "Trying to compare thunks but we should only compare WHNFs"
+        )
+    }
+}
+impl std::cmp::Eq for Thunk {}
+
+impl std::cmp::PartialEq for Closure {
+    fn eq(&self, other: &Self) -> bool {
+        let v = NzVar::fresh();
+        self.apply_var(v) == other.apply_var(v)
+    }
+}
+impl std::cmp::Eq for Closure {}
+
+impl std::fmt::Debug for Value {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let vint: &ValueInternal = &self.as_internal();
+        if let ValueKind::Const(c) = &vint.kind {
+            write!(fmt, "{:?}", c)
+        } else {
+            let mut x = fmt.debug_struct(&format!("Value@{:?}", &vint.form));
+            x.field("value", &vint.kind);
+            if let Some(ty) = vint.ty.as_ref() {
+                x.field("type", &ty);
+            } else {
+                x.field("type", &None::<()>);
+            }
+            x.finish()
+        }
+    }
+}
diff --git a/dhall/src/semantics/nze/var.rs b/dhall/src/semantics/nze/var.rs
new file mode 100644
index 0000000..264b81d
--- /dev/null
+++ b/dhall/src/semantics/nze/var.rs
@@ -0,0 +1,36 @@
+use crate::syntax::Label;
+
+// Exactly like a Label, but equality returns always true.
+// This is so that ValueKind equality is exactly alpha-equivalence.
+#[derive(Clone, Eq)]
+pub struct Binder {
+    name: Label,
+}
+
+impl Binder {
+    pub(crate) fn new(name: Label) -> Self {
+        Binder { name }
+    }
+    pub(crate) fn to_label(&self) -> Label {
+        self.clone().into()
+    }
+}
+
+/// Equality up to alpha-equivalence
+impl std::cmp::PartialEq for Binder {
+    fn eq(&self, _other: &Self) -> bool {
+        true
+    }
+}
+
+impl std::fmt::Debug for Binder {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Binder({})", &self.name)
+    }
+}
+
+impl From<Binder> for Label {
+    fn from(x: Binder) -> Label {
+        x.name
+    }
+}
diff --git a/dhall/src/semantics/nze/visitor.rs b/dhall/src/semantics/nze/visitor.rs
new file mode 100644
index 0000000..d1a85d8
--- /dev/null
+++ b/dhall/src/semantics/nze/visitor.rs
@@ -0,0 +1,167 @@
+use std::iter::FromIterator;
+
+use crate::semantics::{Binder, BuiltinClosure, ValueKind};
+use crate::syntax::Label;
+
+/// A visitor trait that can be used to traverse `ValueKind`s. We need this pattern so that Rust lets
+/// us have as much mutability as we can. See the equivalent file in `crate::syntax` for more
+/// details.
+pub(crate) trait ValueKindVisitor<'a, V1, V2>: Sized {
+    type Error;
+
+    fn visit_val(&mut self, val: &'a V1) -> Result<V2, Self::Error>;
+    fn visit_binder(
+        mut self,
+        _label: &'a Binder,
+        ty: &'a V1,
+        val: &'a V1,
+    ) -> Result<(V2, V2), Self::Error> {
+        Ok((self.visit_val(ty)?, self.visit_val(val)?))
+    }
+    fn visit_vec(&mut self, x: &'a [V1]) -> Result<Vec<V2>, Self::Error> {
+        x.iter().map(|e| self.visit_val(e)).collect()
+    }
+    fn visit_opt(
+        &mut self,
+        x: &'a Option<V1>,
+    ) -> Result<Option<V2>, Self::Error> {
+        Ok(match x {
+            Some(x) => Some(self.visit_val(x)?),
+            None => None,
+        })
+    }
+    fn visit_map<T>(
+        &mut self,
+        x: impl IntoIterator<Item = (&'a Label, &'a V1)>,
+    ) -> Result<T, Self::Error>
+    where
+        V1: 'a,
+        T: FromIterator<(Label, V2)>,
+    {
+        x.into_iter()
+            .map(|(k, x)| Ok((k.clone(), self.visit_val(x)?)))
+            .collect()
+    }
+    fn visit_optmap<T>(
+        &mut self,
+        x: impl IntoIterator<Item = (&'a Label, &'a Option<V1>)>,
+    ) -> Result<T, Self::Error>
+    where
+        V1: 'a,
+        T: FromIterator<(Label, Option<V2>)>,
+    {
+        x.into_iter()
+            .map(|(k, x)| Ok((k.clone(), self.visit_opt(x)?)))
+            .collect()
+    }
+
+    fn visit(
+        self,
+        input: &'a ValueKind<V1>,
+    ) -> Result<ValueKind<V2>, Self::Error> {
+        visit_ref(self, input)
+    }
+}
+
+fn visit_ref<'a, Visitor, V1, V2>(
+    mut v: Visitor,
+    input: &'a ValueKind<V1>,
+) -> Result<ValueKind<V2>, Visitor::Error>
+where
+    Visitor: ValueKindVisitor<'a, V1, V2>,
+{
+    use ValueKind::*;
+    Ok(match input {
+        LamClosure {
+            binder,
+            annot,
+            closure,
+        } => LamClosure {
+            binder: binder.clone(),
+            annot: v.visit_val(annot)?,
+            closure: closure.clone(),
+        },
+        PiClosure {
+            binder,
+            annot,
+            closure,
+        } => PiClosure {
+            binder: binder.clone(),
+            annot: v.visit_val(annot)?,
+            closure: closure.clone(),
+        },
+        AppliedBuiltin(BuiltinClosure {
+            b,
+            args,
+            types,
+            env,
+        }) => AppliedBuiltin(BuiltinClosure {
+            b: *b,
+            args: v.visit_vec(args)?,
+            types: v.visit_vec(types)?,
+            env: env.clone(),
+        }),
+        Var(v) => Var(*v),
+        Const(k) => Const(*k),
+        BoolLit(b) => BoolLit(*b),
+        NaturalLit(n) => NaturalLit(*n),
+        IntegerLit(n) => IntegerLit(*n),
+        DoubleLit(n) => DoubleLit(*n),
+        EmptyOptionalLit(t) => EmptyOptionalLit(v.visit_val(t)?),
+        NEOptionalLit(x) => NEOptionalLit(v.visit_val(x)?),
+        EmptyListLit(t) => EmptyListLit(v.visit_val(t)?),
+        NEListLit(xs) => NEListLit(v.visit_vec(xs)?),
+        RecordType(kts) => RecordType(v.visit_map(kts)?),
+        RecordLit(kvs) => RecordLit(v.visit_map(kvs)?),
+        UnionType(kts) => UnionType(v.visit_optmap(kts)?),
+        UnionConstructor(l, kts, uniont) => UnionConstructor(
+            l.clone(),
+            v.visit_optmap(kts)?,
+            v.visit_val(uniont)?,
+        ),
+        UnionLit(l, x, kts, uniont, ctort) => UnionLit(
+            l.clone(),
+            v.visit_val(x)?,
+            v.visit_optmap(kts)?,
+            v.visit_val(uniont)?,
+            v.visit_val(ctort)?,
+        ),
+        TextLit(ts) => TextLit(
+            ts.iter()
+                .map(|t| t.traverse_ref(|e| v.visit_val(e)))
+                .collect::<Result<_, _>>()?,
+        ),
+        Equivalence(x, y) => Equivalence(v.visit_val(x)?, v.visit_val(y)?),
+        PartialExpr(e) => PartialExpr(e.traverse_ref(|e| v.visit_val(e))?),
+        Thunk(th) => Thunk(th.clone()),
+    })
+}
+
+pub struct TraverseRefWithBindersVisitor<F1, F2> {
+    pub visit_val: F1,
+    pub visit_under_binder: F2,
+}
+
+impl<'a, V1, V2, Err, F1, F2> ValueKindVisitor<'a, V1, V2>
+    for TraverseRefWithBindersVisitor<F1, F2>
+where
+    V1: 'a,
+    F1: FnMut(&'a V1) -> Result<V2, Err>,
+    F2: for<'b> FnOnce(&'a Binder, &'b V1, &'a V1) -> Result<V2, Err>,
+{
+    type Error = Err;
+
+    fn visit_val(&mut self, val: &'a V1) -> Result<V2, Self::Error> {
+        (self.visit_val)(val)
+    }
+    fn visit_binder<'b>(
+        mut self,
+        label: &'a Binder,
+        ty: &'a V1,
+        val: &'a V1,
+    ) -> Result<(V2, V2), Self::Error> {
+        let val = (self.visit_under_binder)(label, ty, val)?;
+        let ty = (self.visit_val)(ty)?;
+        Ok((ty, val))
+    }
+}
-- 
cgit v1.2.3


From 653cdb44cec4f54697d18f2c4ae9f67bbbc2fb3d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 17:04:28 +0000
Subject: Move normalize under nze

---
 dhall/src/semantics/nze/mod.rs         |   2 +
 dhall/src/semantics/nze/normalize.rs   | 507 +++++++++++++++++++++++++++++++++
 dhall/src/semantics/nze/value.rs       |   4 +-
 dhall/src/semantics/phase/mod.rs       |   1 -
 dhall/src/semantics/phase/normalize.rs | 507 ---------------------------------
 dhall/src/semantics/tck/tyexpr.rs      |   2 +-
 dhall/src/semantics/tck/typecheck.rs   |   2 +-
 7 files changed, 512 insertions(+), 513 deletions(-)
 create mode 100644 dhall/src/semantics/nze/normalize.rs
 delete mode 100644 dhall/src/semantics/phase/normalize.rs

(limited to 'dhall')

diff --git a/dhall/src/semantics/nze/mod.rs b/dhall/src/semantics/nze/mod.rs
index f367f8f..e3b37cd 100644
--- a/dhall/src/semantics/nze/mod.rs
+++ b/dhall/src/semantics/nze/mod.rs
@@ -1,7 +1,9 @@
 pub mod env;
+pub mod normalize;
 pub mod value;
 pub mod var;
 pub mod visitor;
 pub(crate) use env::*;
+pub(crate) use normalize::*;
 pub(crate) use value::*;
 pub(crate) use var::*;
diff --git a/dhall/src/semantics/nze/normalize.rs b/dhall/src/semantics/nze/normalize.rs
new file mode 100644
index 0000000..ea1a25b
--- /dev/null
+++ b/dhall/src/semantics/nze/normalize.rs
@@ -0,0 +1,507 @@
+use std::collections::HashMap;
+
+use crate::semantics::phase::Normalized;
+use crate::semantics::NzEnv;
+use crate::semantics::{
+    Binder, BuiltinClosure, Closure, TyExpr, TyExprKind, Value, ValueKind,
+};
+use crate::syntax::{
+    BinOp, Builtin, Const, ExprKind, InterpolatedTextContents,
+};
+
+pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
+    let f_borrow = f.kind();
+    match &*f_borrow {
+        ValueKind::LamClosure { closure, .. } => {
+            closure.apply(a).to_whnf_check_type(ty)
+        }
+        ValueKind::AppliedBuiltin(closure) => {
+            closure.apply(a, f.get_type().unwrap(), ty)
+        }
+        ValueKind::UnionConstructor(l, kts, uniont) => ValueKind::UnionLit(
+            l.clone(),
+            a,
+            kts.clone(),
+            uniont.clone(),
+            f.get_type().unwrap(),
+        ),
+        _ => {
+            drop(f_borrow);
+            ValueKind::PartialExpr(ExprKind::App(f, a))
+        }
+    }
+}
+
+pub(crate) fn squash_textlit(
+    elts: impl Iterator<Item = InterpolatedTextContents<Value>>,
+) -> Vec<InterpolatedTextContents<Value>> {
+    use std::mem::replace;
+    use InterpolatedTextContents::{Expr, Text};
+
+    fn inner(
+        elts: impl Iterator<Item = InterpolatedTextContents<Value>>,
+        crnt_str: &mut String,
+        ret: &mut Vec<InterpolatedTextContents<Value>>,
+    ) {
+        for contents in elts {
+            match contents {
+                Text(s) => crnt_str.push_str(&s),
+                Expr(e) => {
+                    let e_borrow = e.kind();
+                    match &*e_borrow {
+                        ValueKind::TextLit(elts2) => {
+                            inner(elts2.iter().cloned(), crnt_str, ret)
+                        }
+                        _ => {
+                            drop(e_borrow);
+                            if !crnt_str.is_empty() {
+                                ret.push(Text(replace(crnt_str, String::new())))
+                            }
+                            ret.push(Expr(e.clone()))
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    let mut crnt_str = String::new();
+    let mut ret = Vec::new();
+    inner(elts, &mut crnt_str, &mut ret);
+    if !crnt_str.is_empty() {
+        ret.push(Text(replace(&mut crnt_str, String::new())))
+    }
+    ret
+}
+
+pub(crate) fn merge_maps<K, V, F, Err>(
+    map1: &HashMap<K, V>,
+    map2: &HashMap<K, V>,
+    mut f: F,
+) -> Result<HashMap<K, V>, Err>
+where
+    F: FnMut(&K, &V, &V) -> Result<V, Err>,
+    K: std::hash::Hash + Eq + Clone,
+    V: Clone,
+{
+    let mut kvs = HashMap::new();
+    for (x, v2) in map2 {
+        let newv = if let Some(v1) = map1.get(x) {
+            f(x, v1, v2)?
+        } else {
+            v2.clone()
+        };
+        kvs.insert(x.clone(), newv);
+    }
+    for (x, v1) in map1 {
+        // Insert only if key not already present
+        kvs.entry(x.clone()).or_insert_with(|| v1.clone());
+    }
+    Ok(kvs)
+}
+
+// Small helper enum to avoid repetition
+enum Ret<'a> {
+    ValueKind(ValueKind<Value>),
+    Value(Value),
+    ValueRef(&'a Value),
+    Expr(ExprKind<Value, Normalized>),
+}
+
+fn apply_binop<'a>(
+    o: BinOp,
+    x: &'a Value,
+    y: &'a Value,
+    ty: &Value,
+) -> Option<Ret<'a>> {
+    use BinOp::{
+        BoolAnd, BoolEQ, BoolNE, BoolOr, Equivalence, ListAppend, NaturalPlus,
+        NaturalTimes, RecursiveRecordMerge, RecursiveRecordTypeMerge,
+        RightBiasedRecordMerge, TextAppend,
+    };
+    use ValueKind::{
+        BoolLit, EmptyListLit, NEListLit, NaturalLit, RecordLit, RecordType,
+        TextLit,
+    };
+    let x_borrow = x.kind();
+    let y_borrow = y.kind();
+    Some(match (o, &*x_borrow, &*y_borrow) {
+        (BoolAnd, BoolLit(true), _) => Ret::ValueRef(y),
+        (BoolAnd, _, BoolLit(true)) => Ret::ValueRef(x),
+        (BoolAnd, BoolLit(false), _) => Ret::ValueKind(BoolLit(false)),
+        (BoolAnd, _, BoolLit(false)) => Ret::ValueKind(BoolLit(false)),
+        (BoolAnd, _, _) if x == y => Ret::ValueRef(x),
+        (BoolOr, BoolLit(true), _) => Ret::ValueKind(BoolLit(true)),
+        (BoolOr, _, BoolLit(true)) => Ret::ValueKind(BoolLit(true)),
+        (BoolOr, BoolLit(false), _) => Ret::ValueRef(y),
+        (BoolOr, _, BoolLit(false)) => Ret::ValueRef(x),
+        (BoolOr, _, _) if x == y => Ret::ValueRef(x),
+        (BoolEQ, BoolLit(true), _) => Ret::ValueRef(y),
+        (BoolEQ, _, BoolLit(true)) => Ret::ValueRef(x),
+        (BoolEQ, BoolLit(x), BoolLit(y)) => Ret::ValueKind(BoolLit(x == y)),
+        (BoolEQ, _, _) if x == y => Ret::ValueKind(BoolLit(true)),
+        (BoolNE, BoolLit(false), _) => Ret::ValueRef(y),
+        (BoolNE, _, BoolLit(false)) => Ret::ValueRef(x),
+        (BoolNE, BoolLit(x), BoolLit(y)) => Ret::ValueKind(BoolLit(x != y)),
+        (BoolNE, _, _) if x == y => Ret::ValueKind(BoolLit(false)),
+
+        (NaturalPlus, NaturalLit(0), _) => Ret::ValueRef(y),
+        (NaturalPlus, _, NaturalLit(0)) => Ret::ValueRef(x),
+        (NaturalPlus, NaturalLit(x), NaturalLit(y)) => {
+            Ret::ValueKind(NaturalLit(x + y))
+        }
+        (NaturalTimes, NaturalLit(0), _) => Ret::ValueKind(NaturalLit(0)),
+        (NaturalTimes, _, NaturalLit(0)) => Ret::ValueKind(NaturalLit(0)),
+        (NaturalTimes, NaturalLit(1), _) => Ret::ValueRef(y),
+        (NaturalTimes, _, NaturalLit(1)) => Ret::ValueRef(x),
+        (NaturalTimes, NaturalLit(x), NaturalLit(y)) => {
+            Ret::ValueKind(NaturalLit(x * y))
+        }
+
+        (ListAppend, EmptyListLit(_), _) => Ret::ValueRef(y),
+        (ListAppend, _, EmptyListLit(_)) => Ret::ValueRef(x),
+        (ListAppend, NEListLit(xs), NEListLit(ys)) => Ret::ValueKind(
+            NEListLit(xs.iter().chain(ys.iter()).cloned().collect()),
+        ),
+
+        (TextAppend, TextLit(x), _) if x.is_empty() => Ret::ValueRef(y),
+        (TextAppend, _, TextLit(y)) if y.is_empty() => Ret::ValueRef(x),
+        (TextAppend, TextLit(x), TextLit(y)) => Ret::ValueKind(TextLit(
+            squash_textlit(x.iter().chain(y.iter()).cloned()),
+        )),
+        (TextAppend, TextLit(x), _) => {
+            use std::iter::once;
+            let y = InterpolatedTextContents::Expr(y.clone());
+            Ret::ValueKind(TextLit(squash_textlit(
+                x.iter().cloned().chain(once(y)),
+            )))
+        }
+        (TextAppend, _, TextLit(y)) => {
+            use std::iter::once;
+            let x = InterpolatedTextContents::Expr(x.clone());
+            Ret::ValueKind(TextLit(squash_textlit(
+                once(x).chain(y.iter().cloned()),
+            )))
+        }
+
+        (RightBiasedRecordMerge, _, RecordLit(kvs)) if kvs.is_empty() => {
+            Ret::ValueRef(x)
+        }
+        (RightBiasedRecordMerge, RecordLit(kvs), _) if kvs.is_empty() => {
+            Ret::ValueRef(y)
+        }
+        (RightBiasedRecordMerge, RecordLit(kvs1), RecordLit(kvs2)) => {
+            let mut kvs = kvs2.clone();
+            for (x, v) in kvs1 {
+                // Insert only if key not already present
+                kvs.entry(x.clone()).or_insert_with(|| v.clone());
+            }
+            Ret::ValueKind(RecordLit(kvs))
+        }
+
+        (RecursiveRecordMerge, _, RecordLit(kvs)) if kvs.is_empty() => {
+            Ret::ValueRef(x)
+        }
+        (RecursiveRecordMerge, RecordLit(kvs), _) if kvs.is_empty() => {
+            Ret::ValueRef(y)
+        }
+        (RecursiveRecordMerge, RecordLit(kvs1), RecordLit(kvs2)) => {
+            let ty_borrow = ty.kind();
+            let kts = match &*ty_borrow {
+                RecordType(kts) => kts,
+                _ => unreachable!("Internal type error"),
+            };
+            let kvs = merge_maps::<_, _, _, !>(kvs1, kvs2, |k, v1, v2| {
+                Ok(Value::from_kind_and_type(
+                    ValueKind::PartialExpr(ExprKind::BinOp(
+                        RecursiveRecordMerge,
+                        v1.clone(),
+                        v2.clone(),
+                    )),
+                    kts.get(k).expect("Internal type error").clone(),
+                ))
+            })?;
+            Ret::ValueKind(RecordLit(kvs))
+        }
+
+        (RecursiveRecordTypeMerge, RecordType(kts_x), RecordType(kts_y)) => {
+            let kts = merge_maps::<_, _, _, !>(
+                kts_x,
+                kts_y,
+                // If the Label exists for both records, then we hit the recursive case.
+                |_, l: &Value, r: &Value| {
+                    Ok(Value::from_kind_and_type(
+                        ValueKind::PartialExpr(ExprKind::BinOp(
+                            RecursiveRecordTypeMerge,
+                            l.clone(),
+                            r.clone(),
+                        )),
+                        ty.clone(),
+                    ))
+                },
+            )?;
+            Ret::ValueKind(RecordType(kts))
+        }
+
+        (Equivalence, _, _) => {
+            Ret::ValueKind(ValueKind::Equivalence(x.clone(), y.clone()))
+        }
+
+        _ => return None,
+    })
+}
+
+pub(crate) fn normalize_one_layer(
+    expr: ExprKind<Value, Normalized>,
+    ty: &Value,
+    env: &NzEnv,
+) -> ValueKind<Value> {
+    use ValueKind::{
+        BoolLit, DoubleLit, EmptyOptionalLit, IntegerLit, NEListLit,
+        NEOptionalLit, NaturalLit, RecordLit, RecordType, TextLit,
+        UnionConstructor, UnionLit, UnionType,
+    };
+
+    let ret = match expr {
+        ExprKind::Import(_) => unreachable!(
+            "There should remain no imports in a resolved expression"
+        ),
+        // Those cases have already been completely handled in the typechecking phase (using
+        // `RetWhole`), so they won't appear here.
+        ExprKind::Lam(..)
+        | ExprKind::Pi(..)
+        | ExprKind::Let(..)
+        | ExprKind::Embed(_)
+        | ExprKind::Var(_) => {
+            unreachable!("This case should have been handled in typecheck")
+        }
+        ExprKind::Annot(x, _) => Ret::Value(x),
+        ExprKind::Const(c) => Ret::Value(Value::from_const(c)),
+        ExprKind::Builtin(b) => Ret::Value(Value::from_builtin_env(b, env)),
+        ExprKind::Assert(_) => Ret::Expr(expr),
+        ExprKind::App(v, a) => Ret::Value(v.app(a)),
+        ExprKind::BoolLit(b) => Ret::ValueKind(BoolLit(b)),
+        ExprKind::NaturalLit(n) => Ret::ValueKind(NaturalLit(n)),
+        ExprKind::IntegerLit(n) => Ret::ValueKind(IntegerLit(n)),
+        ExprKind::DoubleLit(n) => Ret::ValueKind(DoubleLit(n)),
+        ExprKind::SomeLit(e) => Ret::ValueKind(NEOptionalLit(e)),
+        ExprKind::EmptyListLit(t) => {
+            let arg = match &*t.kind() {
+                ValueKind::AppliedBuiltin(BuiltinClosure {
+                    b: Builtin::List,
+                    args,
+                    ..
+                }) if args.len() == 1 => args[0].clone(),
+                _ => panic!("internal type error"),
+            };
+            Ret::ValueKind(ValueKind::EmptyListLit(arg))
+        }
+        ExprKind::NEListLit(elts) => {
+            Ret::ValueKind(NEListLit(elts.into_iter().collect()))
+        }
+        ExprKind::RecordLit(kvs) => {
+            Ret::ValueKind(RecordLit(kvs.into_iter().collect()))
+        }
+        ExprKind::RecordType(kvs) => {
+            Ret::ValueKind(RecordType(kvs.into_iter().collect()))
+        }
+        ExprKind::UnionType(kvs) => {
+            Ret::ValueKind(UnionType(kvs.into_iter().collect()))
+        }
+        ExprKind::TextLit(elts) => {
+            use InterpolatedTextContents::Expr;
+            let elts: Vec<_> = squash_textlit(elts.into_iter());
+            // Simplify bare interpolation
+            if let [Expr(th)] = elts.as_slice() {
+                Ret::Value(th.clone())
+            } else {
+                Ret::ValueKind(TextLit(elts))
+            }
+        }
+        ExprKind::BoolIf(ref b, ref e1, ref e2) => {
+            let b_borrow = b.kind();
+            match &*b_borrow {
+                BoolLit(true) => Ret::ValueRef(e1),
+                BoolLit(false) => Ret::ValueRef(e2),
+                _ => {
+                    let e1_borrow = e1.kind();
+                    let e2_borrow = e2.kind();
+                    match (&*e1_borrow, &*e2_borrow) {
+                        // Simplify `if b then True else False`
+                        (BoolLit(true), BoolLit(false)) => Ret::ValueRef(b),
+                        _ if e1 == e2 => Ret::ValueRef(e1),
+                        _ => {
+                            drop(b_borrow);
+                            drop(e1_borrow);
+                            drop(e2_borrow);
+                            Ret::Expr(expr)
+                        }
+                    }
+                }
+            }
+        }
+        ExprKind::BinOp(o, ref x, ref y) => match apply_binop(o, x, y, ty) {
+            Some(ret) => ret,
+            None => Ret::Expr(expr),
+        },
+
+        ExprKind::Projection(_, ref ls) if ls.is_empty() => {
+            Ret::ValueKind(RecordLit(HashMap::new()))
+        }
+        ExprKind::Projection(ref v, ref ls) => {
+            let v_borrow = v.kind();
+            match &*v_borrow {
+                RecordLit(kvs) => Ret::ValueKind(RecordLit(
+                    ls.iter()
+                        .filter_map(|l| {
+                            kvs.get(l).map(|x| (l.clone(), x.clone()))
+                        })
+                        .collect(),
+                )),
+                _ => {
+                    drop(v_borrow);
+                    Ret::Expr(expr)
+                }
+            }
+        }
+        ExprKind::Field(ref v, ref l) => {
+            let v_borrow = v.kind();
+            match &*v_borrow {
+                RecordLit(kvs) => match kvs.get(l) {
+                    Some(r) => Ret::Value(r.clone()),
+                    None => {
+                        drop(v_borrow);
+                        Ret::Expr(expr)
+                    }
+                },
+                UnionType(kts) => Ret::ValueKind(UnionConstructor(
+                    l.clone(),
+                    kts.clone(),
+                    v.get_type().unwrap(),
+                )),
+                _ => {
+                    drop(v_borrow);
+                    Ret::Expr(expr)
+                }
+            }
+        }
+        ExprKind::ProjectionByExpr(_, _) => {
+            unimplemented!("selection by expression")
+        }
+        ExprKind::Completion(_, _) => unimplemented!("record completion"),
+
+        ExprKind::Merge(ref handlers, ref variant, _) => {
+            let handlers_borrow = handlers.kind();
+            let variant_borrow = variant.kind();
+            match (&*handlers_borrow, &*variant_borrow) {
+                (RecordLit(kvs), UnionConstructor(l, _, _)) => match kvs.get(l)
+                {
+                    Some(h) => Ret::Value(h.clone()),
+                    None => {
+                        drop(handlers_borrow);
+                        drop(variant_borrow);
+                        Ret::Expr(expr)
+                    }
+                },
+                (RecordLit(kvs), UnionLit(l, v, _, _, _)) => match kvs.get(l) {
+                    Some(h) => Ret::Value(h.app(v.clone())),
+                    None => {
+                        drop(handlers_borrow);
+                        drop(variant_borrow);
+                        Ret::Expr(expr)
+                    }
+                },
+                (RecordLit(kvs), EmptyOptionalLit(_)) => {
+                    match kvs.get(&"None".into()) {
+                        Some(h) => Ret::Value(h.clone()),
+                        None => {
+                            drop(handlers_borrow);
+                            drop(variant_borrow);
+                            Ret::Expr(expr)
+                        }
+                    }
+                }
+                (RecordLit(kvs), NEOptionalLit(v)) => {
+                    match kvs.get(&"Some".into()) {
+                        Some(h) => Ret::Value(h.app(v.clone())),
+                        None => {
+                            drop(handlers_borrow);
+                            drop(variant_borrow);
+                            Ret::Expr(expr)
+                        }
+                    }
+                }
+                _ => {
+                    drop(handlers_borrow);
+                    drop(variant_borrow);
+                    Ret::Expr(expr)
+                }
+            }
+        }
+        ExprKind::ToMap(_, _) => unimplemented!("toMap"),
+    };
+
+    match ret {
+        Ret::ValueKind(v) => v,
+        Ret::Value(v) => v.to_whnf_check_type(ty),
+        Ret::ValueRef(v) => v.to_whnf_check_type(ty),
+        Ret::Expr(expr) => ValueKind::PartialExpr(expr),
+    }
+}
+
+/// Normalize a ValueKind into WHNF
+pub(crate) fn normalize_whnf(
+    v: ValueKind<Value>,
+    ty: &Value,
+) -> ValueKind<Value> {
+    match v {
+        ValueKind::AppliedBuiltin(closure) => closure.ensure_whnf(ty),
+        ValueKind::PartialExpr(e) => normalize_one_layer(e, ty, &NzEnv::new()),
+        ValueKind::Thunk(th) => th.eval().kind().clone(),
+        ValueKind::TextLit(elts) => {
+            ValueKind::TextLit(squash_textlit(elts.into_iter()))
+        }
+        // All other cases are already in WHNF
+        v => v,
+    }
+}
+
+/// Normalize a TyExpr into WHNF
+pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> Value {
+    let ty = match tye.get_type() {
+        Ok(ty) => ty,
+        Err(_) => return Value::from_const(Const::Sort),
+    };
+
+    let kind = match tye.kind() {
+        TyExprKind::Var(var) => return env.lookup_val(var),
+        TyExprKind::Expr(ExprKind::Lam(binder, annot, body)) => {
+            let annot = annot.eval(env);
+            ValueKind::LamClosure {
+                binder: Binder::new(binder.clone()),
+                annot: annot.clone(),
+                closure: Closure::new(annot, env, body.clone()),
+            }
+        }
+        TyExprKind::Expr(ExprKind::Pi(binder, annot, body)) => {
+            let annot = annot.eval(env);
+            let closure = Closure::new(annot.clone(), env, body.clone());
+            ValueKind::PiClosure {
+                binder: Binder::new(binder.clone()),
+                annot,
+                closure,
+            }
+        }
+        TyExprKind::Expr(ExprKind::Let(_, None, val, body)) => {
+            let val = val.eval(env);
+            return body.eval(&env.insert_value(val));
+        }
+        TyExprKind::Expr(e) => {
+            let e = e.map_ref(|tye| tye.eval(env));
+            normalize_one_layer(e, &ty, env)
+        }
+    };
+
+    // dbg!(tye.kind(), env, &kind);
+    Value::from_kind_and_type_whnf(kind, ty)
+}
diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index 4960076..215c342 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -4,11 +4,9 @@ use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::nze::visitor;
-use crate::semantics::phase::normalize::{
-    apply_any, normalize_tyexpr_whnf, normalize_whnf,
-};
 use crate::semantics::phase::{Normalized, NormalizedExpr, ToExprOptions};
 use crate::semantics::Binder;
+use crate::semantics::{apply_any, normalize_tyexpr_whnf, normalize_whnf};
 use crate::semantics::{type_of_builtin, typecheck, TyExpr, TyExprKind};
 use crate::semantics::{BuiltinClosure, NzEnv, NzVar, VarEnv};
 use crate::syntax::{
diff --git a/dhall/src/semantics/phase/mod.rs b/dhall/src/semantics/phase/mod.rs
index a25f096..ff4b859 100644
--- a/dhall/src/semantics/phase/mod.rs
+++ b/dhall/src/semantics/phase/mod.rs
@@ -7,7 +7,6 @@ use crate::syntax::binary;
 use crate::syntax::{Builtin, Const, Expr};
 use resolve::ImportRoot;
 
-pub(crate) mod normalize;
 pub(crate) mod parse;
 pub(crate) mod resolve;
 
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
deleted file mode 100644
index ea1a25b..0000000
--- a/dhall/src/semantics/phase/normalize.rs
+++ /dev/null
@@ -1,507 +0,0 @@
-use std::collections::HashMap;
-
-use crate::semantics::phase::Normalized;
-use crate::semantics::NzEnv;
-use crate::semantics::{
-    Binder, BuiltinClosure, Closure, TyExpr, TyExprKind, Value, ValueKind,
-};
-use crate::syntax::{
-    BinOp, Builtin, Const, ExprKind, InterpolatedTextContents,
-};
-
-pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
-    let f_borrow = f.kind();
-    match &*f_borrow {
-        ValueKind::LamClosure { closure, .. } => {
-            closure.apply(a).to_whnf_check_type(ty)
-        }
-        ValueKind::AppliedBuiltin(closure) => {
-            closure.apply(a, f.get_type().unwrap(), ty)
-        }
-        ValueKind::UnionConstructor(l, kts, uniont) => ValueKind::UnionLit(
-            l.clone(),
-            a,
-            kts.clone(),
-            uniont.clone(),
-            f.get_type().unwrap(),
-        ),
-        _ => {
-            drop(f_borrow);
-            ValueKind::PartialExpr(ExprKind::App(f, a))
-        }
-    }
-}
-
-pub(crate) fn squash_textlit(
-    elts: impl Iterator<Item = InterpolatedTextContents<Value>>,
-) -> Vec<InterpolatedTextContents<Value>> {
-    use std::mem::replace;
-    use InterpolatedTextContents::{Expr, Text};
-
-    fn inner(
-        elts: impl Iterator<Item = InterpolatedTextContents<Value>>,
-        crnt_str: &mut String,
-        ret: &mut Vec<InterpolatedTextContents<Value>>,
-    ) {
-        for contents in elts {
-            match contents {
-                Text(s) => crnt_str.push_str(&s),
-                Expr(e) => {
-                    let e_borrow = e.kind();
-                    match &*e_borrow {
-                        ValueKind::TextLit(elts2) => {
-                            inner(elts2.iter().cloned(), crnt_str, ret)
-                        }
-                        _ => {
-                            drop(e_borrow);
-                            if !crnt_str.is_empty() {
-                                ret.push(Text(replace(crnt_str, String::new())))
-                            }
-                            ret.push(Expr(e.clone()))
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    let mut crnt_str = String::new();
-    let mut ret = Vec::new();
-    inner(elts, &mut crnt_str, &mut ret);
-    if !crnt_str.is_empty() {
-        ret.push(Text(replace(&mut crnt_str, String::new())))
-    }
-    ret
-}
-
-pub(crate) fn merge_maps<K, V, F, Err>(
-    map1: &HashMap<K, V>,
-    map2: &HashMap<K, V>,
-    mut f: F,
-) -> Result<HashMap<K, V>, Err>
-where
-    F: FnMut(&K, &V, &V) -> Result<V, Err>,
-    K: std::hash::Hash + Eq + Clone,
-    V: Clone,
-{
-    let mut kvs = HashMap::new();
-    for (x, v2) in map2 {
-        let newv = if let Some(v1) = map1.get(x) {
-            f(x, v1, v2)?
-        } else {
-            v2.clone()
-        };
-        kvs.insert(x.clone(), newv);
-    }
-    for (x, v1) in map1 {
-        // Insert only if key not already present
-        kvs.entry(x.clone()).or_insert_with(|| v1.clone());
-    }
-    Ok(kvs)
-}
-
-// Small helper enum to avoid repetition
-enum Ret<'a> {
-    ValueKind(ValueKind<Value>),
-    Value(Value),
-    ValueRef(&'a Value),
-    Expr(ExprKind<Value, Normalized>),
-}
-
-fn apply_binop<'a>(
-    o: BinOp,
-    x: &'a Value,
-    y: &'a Value,
-    ty: &Value,
-) -> Option<Ret<'a>> {
-    use BinOp::{
-        BoolAnd, BoolEQ, BoolNE, BoolOr, Equivalence, ListAppend, NaturalPlus,
-        NaturalTimes, RecursiveRecordMerge, RecursiveRecordTypeMerge,
-        RightBiasedRecordMerge, TextAppend,
-    };
-    use ValueKind::{
-        BoolLit, EmptyListLit, NEListLit, NaturalLit, RecordLit, RecordType,
-        TextLit,
-    };
-    let x_borrow = x.kind();
-    let y_borrow = y.kind();
-    Some(match (o, &*x_borrow, &*y_borrow) {
-        (BoolAnd, BoolLit(true), _) => Ret::ValueRef(y),
-        (BoolAnd, _, BoolLit(true)) => Ret::ValueRef(x),
-        (BoolAnd, BoolLit(false), _) => Ret::ValueKind(BoolLit(false)),
-        (BoolAnd, _, BoolLit(false)) => Ret::ValueKind(BoolLit(false)),
-        (BoolAnd, _, _) if x == y => Ret::ValueRef(x),
-        (BoolOr, BoolLit(true), _) => Ret::ValueKind(BoolLit(true)),
-        (BoolOr, _, BoolLit(true)) => Ret::ValueKind(BoolLit(true)),
-        (BoolOr, BoolLit(false), _) => Ret::ValueRef(y),
-        (BoolOr, _, BoolLit(false)) => Ret::ValueRef(x),
-        (BoolOr, _, _) if x == y => Ret::ValueRef(x),
-        (BoolEQ, BoolLit(true), _) => Ret::ValueRef(y),
-        (BoolEQ, _, BoolLit(true)) => Ret::ValueRef(x),
-        (BoolEQ, BoolLit(x), BoolLit(y)) => Ret::ValueKind(BoolLit(x == y)),
-        (BoolEQ, _, _) if x == y => Ret::ValueKind(BoolLit(true)),
-        (BoolNE, BoolLit(false), _) => Ret::ValueRef(y),
-        (BoolNE, _, BoolLit(false)) => Ret::ValueRef(x),
-        (BoolNE, BoolLit(x), BoolLit(y)) => Ret::ValueKind(BoolLit(x != y)),
-        (BoolNE, _, _) if x == y => Ret::ValueKind(BoolLit(false)),
-
-        (NaturalPlus, NaturalLit(0), _) => Ret::ValueRef(y),
-        (NaturalPlus, _, NaturalLit(0)) => Ret::ValueRef(x),
-        (NaturalPlus, NaturalLit(x), NaturalLit(y)) => {
-            Ret::ValueKind(NaturalLit(x + y))
-        }
-        (NaturalTimes, NaturalLit(0), _) => Ret::ValueKind(NaturalLit(0)),
-        (NaturalTimes, _, NaturalLit(0)) => Ret::ValueKind(NaturalLit(0)),
-        (NaturalTimes, NaturalLit(1), _) => Ret::ValueRef(y),
-        (NaturalTimes, _, NaturalLit(1)) => Ret::ValueRef(x),
-        (NaturalTimes, NaturalLit(x), NaturalLit(y)) => {
-            Ret::ValueKind(NaturalLit(x * y))
-        }
-
-        (ListAppend, EmptyListLit(_), _) => Ret::ValueRef(y),
-        (ListAppend, _, EmptyListLit(_)) => Ret::ValueRef(x),
-        (ListAppend, NEListLit(xs), NEListLit(ys)) => Ret::ValueKind(
-            NEListLit(xs.iter().chain(ys.iter()).cloned().collect()),
-        ),
-
-        (TextAppend, TextLit(x), _) if x.is_empty() => Ret::ValueRef(y),
-        (TextAppend, _, TextLit(y)) if y.is_empty() => Ret::ValueRef(x),
-        (TextAppend, TextLit(x), TextLit(y)) => Ret::ValueKind(TextLit(
-            squash_textlit(x.iter().chain(y.iter()).cloned()),
-        )),
-        (TextAppend, TextLit(x), _) => {
-            use std::iter::once;
-            let y = InterpolatedTextContents::Expr(y.clone());
-            Ret::ValueKind(TextLit(squash_textlit(
-                x.iter().cloned().chain(once(y)),
-            )))
-        }
-        (TextAppend, _, TextLit(y)) => {
-            use std::iter::once;
-            let x = InterpolatedTextContents::Expr(x.clone());
-            Ret::ValueKind(TextLit(squash_textlit(
-                once(x).chain(y.iter().cloned()),
-            )))
-        }
-
-        (RightBiasedRecordMerge, _, RecordLit(kvs)) if kvs.is_empty() => {
-            Ret::ValueRef(x)
-        }
-        (RightBiasedRecordMerge, RecordLit(kvs), _) if kvs.is_empty() => {
-            Ret::ValueRef(y)
-        }
-        (RightBiasedRecordMerge, RecordLit(kvs1), RecordLit(kvs2)) => {
-            let mut kvs = kvs2.clone();
-            for (x, v) in kvs1 {
-                // Insert only if key not already present
-                kvs.entry(x.clone()).or_insert_with(|| v.clone());
-            }
-            Ret::ValueKind(RecordLit(kvs))
-        }
-
-        (RecursiveRecordMerge, _, RecordLit(kvs)) if kvs.is_empty() => {
-            Ret::ValueRef(x)
-        }
-        (RecursiveRecordMerge, RecordLit(kvs), _) if kvs.is_empty() => {
-            Ret::ValueRef(y)
-        }
-        (RecursiveRecordMerge, RecordLit(kvs1), RecordLit(kvs2)) => {
-            let ty_borrow = ty.kind();
-            let kts = match &*ty_borrow {
-                RecordType(kts) => kts,
-                _ => unreachable!("Internal type error"),
-            };
-            let kvs = merge_maps::<_, _, _, !>(kvs1, kvs2, |k, v1, v2| {
-                Ok(Value::from_kind_and_type(
-                    ValueKind::PartialExpr(ExprKind::BinOp(
-                        RecursiveRecordMerge,
-                        v1.clone(),
-                        v2.clone(),
-                    )),
-                    kts.get(k).expect("Internal type error").clone(),
-                ))
-            })?;
-            Ret::ValueKind(RecordLit(kvs))
-        }
-
-        (RecursiveRecordTypeMerge, RecordType(kts_x), RecordType(kts_y)) => {
-            let kts = merge_maps::<_, _, _, !>(
-                kts_x,
-                kts_y,
-                // If the Label exists for both records, then we hit the recursive case.
-                |_, l: &Value, r: &Value| {
-                    Ok(Value::from_kind_and_type(
-                        ValueKind::PartialExpr(ExprKind::BinOp(
-                            RecursiveRecordTypeMerge,
-                            l.clone(),
-                            r.clone(),
-                        )),
-                        ty.clone(),
-                    ))
-                },
-            )?;
-            Ret::ValueKind(RecordType(kts))
-        }
-
-        (Equivalence, _, _) => {
-            Ret::ValueKind(ValueKind::Equivalence(x.clone(), y.clone()))
-        }
-
-        _ => return None,
-    })
-}
-
-pub(crate) fn normalize_one_layer(
-    expr: ExprKind<Value, Normalized>,
-    ty: &Value,
-    env: &NzEnv,
-) -> ValueKind<Value> {
-    use ValueKind::{
-        BoolLit, DoubleLit, EmptyOptionalLit, IntegerLit, NEListLit,
-        NEOptionalLit, NaturalLit, RecordLit, RecordType, TextLit,
-        UnionConstructor, UnionLit, UnionType,
-    };
-
-    let ret = match expr {
-        ExprKind::Import(_) => unreachable!(
-            "There should remain no imports in a resolved expression"
-        ),
-        // Those cases have already been completely handled in the typechecking phase (using
-        // `RetWhole`), so they won't appear here.
-        ExprKind::Lam(..)
-        | ExprKind::Pi(..)
-        | ExprKind::Let(..)
-        | ExprKind::Embed(_)
-        | ExprKind::Var(_) => {
-            unreachable!("This case should have been handled in typecheck")
-        }
-        ExprKind::Annot(x, _) => Ret::Value(x),
-        ExprKind::Const(c) => Ret::Value(Value::from_const(c)),
-        ExprKind::Builtin(b) => Ret::Value(Value::from_builtin_env(b, env)),
-        ExprKind::Assert(_) => Ret::Expr(expr),
-        ExprKind::App(v, a) => Ret::Value(v.app(a)),
-        ExprKind::BoolLit(b) => Ret::ValueKind(BoolLit(b)),
-        ExprKind::NaturalLit(n) => Ret::ValueKind(NaturalLit(n)),
-        ExprKind::IntegerLit(n) => Ret::ValueKind(IntegerLit(n)),
-        ExprKind::DoubleLit(n) => Ret::ValueKind(DoubleLit(n)),
-        ExprKind::SomeLit(e) => Ret::ValueKind(NEOptionalLit(e)),
-        ExprKind::EmptyListLit(t) => {
-            let arg = match &*t.kind() {
-                ValueKind::AppliedBuiltin(BuiltinClosure {
-                    b: Builtin::List,
-                    args,
-                    ..
-                }) if args.len() == 1 => args[0].clone(),
-                _ => panic!("internal type error"),
-            };
-            Ret::ValueKind(ValueKind::EmptyListLit(arg))
-        }
-        ExprKind::NEListLit(elts) => {
-            Ret::ValueKind(NEListLit(elts.into_iter().collect()))
-        }
-        ExprKind::RecordLit(kvs) => {
-            Ret::ValueKind(RecordLit(kvs.into_iter().collect()))
-        }
-        ExprKind::RecordType(kvs) => {
-            Ret::ValueKind(RecordType(kvs.into_iter().collect()))
-        }
-        ExprKind::UnionType(kvs) => {
-            Ret::ValueKind(UnionType(kvs.into_iter().collect()))
-        }
-        ExprKind::TextLit(elts) => {
-            use InterpolatedTextContents::Expr;
-            let elts: Vec<_> = squash_textlit(elts.into_iter());
-            // Simplify bare interpolation
-            if let [Expr(th)] = elts.as_slice() {
-                Ret::Value(th.clone())
-            } else {
-                Ret::ValueKind(TextLit(elts))
-            }
-        }
-        ExprKind::BoolIf(ref b, ref e1, ref e2) => {
-            let b_borrow = b.kind();
-            match &*b_borrow {
-                BoolLit(true) => Ret::ValueRef(e1),
-                BoolLit(false) => Ret::ValueRef(e2),
-                _ => {
-                    let e1_borrow = e1.kind();
-                    let e2_borrow = e2.kind();
-                    match (&*e1_borrow, &*e2_borrow) {
-                        // Simplify `if b then True else False`
-                        (BoolLit(true), BoolLit(false)) => Ret::ValueRef(b),
-                        _ if e1 == e2 => Ret::ValueRef(e1),
-                        _ => {
-                            drop(b_borrow);
-                            drop(e1_borrow);
-                            drop(e2_borrow);
-                            Ret::Expr(expr)
-                        }
-                    }
-                }
-            }
-        }
-        ExprKind::BinOp(o, ref x, ref y) => match apply_binop(o, x, y, ty) {
-            Some(ret) => ret,
-            None => Ret::Expr(expr),
-        },
-
-        ExprKind::Projection(_, ref ls) if ls.is_empty() => {
-            Ret::ValueKind(RecordLit(HashMap::new()))
-        }
-        ExprKind::Projection(ref v, ref ls) => {
-            let v_borrow = v.kind();
-            match &*v_borrow {
-                RecordLit(kvs) => Ret::ValueKind(RecordLit(
-                    ls.iter()
-                        .filter_map(|l| {
-                            kvs.get(l).map(|x| (l.clone(), x.clone()))
-                        })
-                        .collect(),
-                )),
-                _ => {
-                    drop(v_borrow);
-                    Ret::Expr(expr)
-                }
-            }
-        }
-        ExprKind::Field(ref v, ref l) => {
-            let v_borrow = v.kind();
-            match &*v_borrow {
-                RecordLit(kvs) => match kvs.get(l) {
-                    Some(r) => Ret::Value(r.clone()),
-                    None => {
-                        drop(v_borrow);
-                        Ret::Expr(expr)
-                    }
-                },
-                UnionType(kts) => Ret::ValueKind(UnionConstructor(
-                    l.clone(),
-                    kts.clone(),
-                    v.get_type().unwrap(),
-                )),
-                _ => {
-                    drop(v_borrow);
-                    Ret::Expr(expr)
-                }
-            }
-        }
-        ExprKind::ProjectionByExpr(_, _) => {
-            unimplemented!("selection by expression")
-        }
-        ExprKind::Completion(_, _) => unimplemented!("record completion"),
-
-        ExprKind::Merge(ref handlers, ref variant, _) => {
-            let handlers_borrow = handlers.kind();
-            let variant_borrow = variant.kind();
-            match (&*handlers_borrow, &*variant_borrow) {
-                (RecordLit(kvs), UnionConstructor(l, _, _)) => match kvs.get(l)
-                {
-                    Some(h) => Ret::Value(h.clone()),
-                    None => {
-                        drop(handlers_borrow);
-                        drop(variant_borrow);
-                        Ret::Expr(expr)
-                    }
-                },
-                (RecordLit(kvs), UnionLit(l, v, _, _, _)) => match kvs.get(l) {
-                    Some(h) => Ret::Value(h.app(v.clone())),
-                    None => {
-                        drop(handlers_borrow);
-                        drop(variant_borrow);
-                        Ret::Expr(expr)
-                    }
-                },
-                (RecordLit(kvs), EmptyOptionalLit(_)) => {
-                    match kvs.get(&"None".into()) {
-                        Some(h) => Ret::Value(h.clone()),
-                        None => {
-                            drop(handlers_borrow);
-                            drop(variant_borrow);
-                            Ret::Expr(expr)
-                        }
-                    }
-                }
-                (RecordLit(kvs), NEOptionalLit(v)) => {
-                    match kvs.get(&"Some".into()) {
-                        Some(h) => Ret::Value(h.app(v.clone())),
-                        None => {
-                            drop(handlers_borrow);
-                            drop(variant_borrow);
-                            Ret::Expr(expr)
-                        }
-                    }
-                }
-                _ => {
-                    drop(handlers_borrow);
-                    drop(variant_borrow);
-                    Ret::Expr(expr)
-                }
-            }
-        }
-        ExprKind::ToMap(_, _) => unimplemented!("toMap"),
-    };
-
-    match ret {
-        Ret::ValueKind(v) => v,
-        Ret::Value(v) => v.to_whnf_check_type(ty),
-        Ret::ValueRef(v) => v.to_whnf_check_type(ty),
-        Ret::Expr(expr) => ValueKind::PartialExpr(expr),
-    }
-}
-
-/// Normalize a ValueKind into WHNF
-pub(crate) fn normalize_whnf(
-    v: ValueKind<Value>,
-    ty: &Value,
-) -> ValueKind<Value> {
-    match v {
-        ValueKind::AppliedBuiltin(closure) => closure.ensure_whnf(ty),
-        ValueKind::PartialExpr(e) => normalize_one_layer(e, ty, &NzEnv::new()),
-        ValueKind::Thunk(th) => th.eval().kind().clone(),
-        ValueKind::TextLit(elts) => {
-            ValueKind::TextLit(squash_textlit(elts.into_iter()))
-        }
-        // All other cases are already in WHNF
-        v => v,
-    }
-}
-
-/// Normalize a TyExpr into WHNF
-pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> Value {
-    let ty = match tye.get_type() {
-        Ok(ty) => ty,
-        Err(_) => return Value::from_const(Const::Sort),
-    };
-
-    let kind = match tye.kind() {
-        TyExprKind::Var(var) => return env.lookup_val(var),
-        TyExprKind::Expr(ExprKind::Lam(binder, annot, body)) => {
-            let annot = annot.eval(env);
-            ValueKind::LamClosure {
-                binder: Binder::new(binder.clone()),
-                annot: annot.clone(),
-                closure: Closure::new(annot, env, body.clone()),
-            }
-        }
-        TyExprKind::Expr(ExprKind::Pi(binder, annot, body)) => {
-            let annot = annot.eval(env);
-            let closure = Closure::new(annot.clone(), env, body.clone());
-            ValueKind::PiClosure {
-                binder: Binder::new(binder.clone()),
-                annot,
-                closure,
-            }
-        }
-        TyExprKind::Expr(ExprKind::Let(_, None, val, body)) => {
-            let val = val.eval(env);
-            return body.eval(&env.insert_value(val));
-        }
-        TyExprKind::Expr(e) => {
-            let e = e.map_ref(|tye| tye.eval(env));
-            normalize_one_layer(e, &ty, env)
-        }
-    };
-
-    // dbg!(tye.kind(), env, &kind);
-    Value::from_kind_and_type_whnf(kind, ty)
-}
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index 0a27f32..98dc3f9 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -1,5 +1,5 @@
 use crate::error::{TypeError, TypeMessage};
-use crate::semantics::phase::normalize::normalize_tyexpr_whnf;
+use crate::semantics::normalize_tyexpr_whnf;
 use crate::semantics::phase::Normalized;
 use crate::semantics::phase::{NormalizedExpr, ToExprOptions};
 use crate::semantics::{rc, NameEnv, NzEnv, TyEnv, Value};
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index d741b40..348471f 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -3,7 +3,7 @@ use std::cmp::max;
 use std::collections::HashMap;
 
 use crate::error::{TypeError, TypeMessage};
-use crate::semantics::phase::normalize::merge_maps;
+use crate::semantics::merge_maps;
 use crate::semantics::phase::Normalized;
 use crate::semantics::{
     type_of_builtin, Binder, BuiltinClosure, Closure, TyEnv, TyExpr,
-- 
cgit v1.2.3


From 5197c26c23edd6c499f8e0f8a239fe4393b2e3d2 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 17:09:16 +0000
Subject: Move main API to lib.rs

---
 dhall/src/error/mod.rs               |   2 +-
 dhall/src/lib.rs                     | 244 +++++++++++++++++++++++++++++++++++
 dhall/src/semantics/builtins.rs      |   2 +-
 dhall/src/semantics/nze/normalize.rs |   2 +-
 dhall/src/semantics/nze/value.rs     |   2 +-
 dhall/src/semantics/phase/mod.rs     | 242 ----------------------------------
 dhall/src/semantics/phase/parse.rs   |   2 +-
 dhall/src/semantics/phase/resolve.rs |   2 +-
 dhall/src/semantics/tck/tyexpr.rs    |   4 +-
 dhall/src/semantics/tck/typecheck.rs |   2 +-
 dhall/src/syntax/binary/decode.rs    |   2 +-
 dhall/src/syntax/text/parser.rs      |   2 +-
 dhall/src/tests.rs                   |   2 +-
 13 files changed, 256 insertions(+), 254 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index 852e795..8991758 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -1,9 +1,9 @@
 use std::io::Error as IOError;
 
 use crate::semantics::phase::resolve::ImportStack;
-use crate::semantics::phase::NormalizedExpr;
 use crate::semantics::Value;
 use crate::syntax::{Import, ParseError};
+use crate::NormalizedExpr;
 
 pub type Result<T> = std::result::Result<T, Error>;
 
diff --git a/dhall/src/lib.rs b/dhall/src/lib.rs
index 62a1b27..cbf3ceb 100644
--- a/dhall/src/lib.rs
+++ b/dhall/src/lib.rs
@@ -16,3 +16,247 @@ mod tests;
 pub mod error;
 pub mod semantics;
 pub mod syntax;
+
+use std::fmt::Display;
+use std::path::Path;
+
+use crate::error::{EncodeError, Error, ImportError, TypeError};
+use crate::semantics::phase::parse;
+use crate::semantics::phase::resolve;
+use crate::semantics::phase::resolve::ImportRoot;
+use crate::semantics::{typecheck, typecheck_with, TyExpr, Value, ValueKind};
+use crate::syntax::binary;
+use crate::syntax::{Builtin, Const, Expr};
+
+pub type ParsedExpr = Expr<Normalized>;
+pub type DecodedExpr = Expr<Normalized>;
+pub type ResolvedExpr = Expr<Normalized>;
+pub type NormalizedExpr = Expr<Normalized>;
+
+#[derive(Debug, Clone)]
+pub struct Parsed(ParsedExpr, ImportRoot);
+
+/// An expression where all imports have been resolved
+///
+/// Invariant: there must be no `Import` nodes or `ImportAlt` operations left.
+#[derive(Debug, Clone)]
+pub struct Resolved(ResolvedExpr);
+
+/// A typed expression
+#[derive(Debug, Clone)]
+pub struct Typed(TyExpr);
+
+/// A normalized expression.
+///
+/// Invariant: the contained Typed expression must be in normal form,
+#[derive(Debug, Clone)]
+pub struct Normalized(Value);
+
+/// Controls conversion from `Value` to `Expr`
+#[derive(Copy, Clone)]
+pub(crate) struct ToExprOptions {
+    /// Whether to convert all variables to `_`
+    pub(crate) alpha: bool,
+    /// Whether to normalize before converting
+    pub(crate) normalize: bool,
+}
+
+impl Parsed {
+    pub fn parse_file(f: &Path) -> Result<Parsed, Error> {
+        parse::parse_file(f)
+    }
+    pub fn parse_str(s: &str) -> Result<Parsed, Error> {
+        parse::parse_str(s)
+    }
+    pub fn parse_binary_file(f: &Path) -> Result<Parsed, Error> {
+        parse::parse_binary_file(f)
+    }
+    pub fn parse_binary(data: &[u8]) -> Result<Parsed, Error> {
+        parse::parse_binary(data)
+    }
+
+    pub fn resolve(self) -> Result<Resolved, ImportError> {
+        resolve::resolve(self)
+    }
+    pub fn skip_resolve(self) -> Result<Resolved, ImportError> {
+        resolve::skip_resolve_expr(self)
+    }
+
+    pub fn encode(&self) -> Result<Vec<u8>, EncodeError> {
+        binary::encode(&self.0)
+    }
+
+    /// Converts a value back to the corresponding AST expression.
+    pub fn to_expr(&self) -> ParsedExpr {
+        self.0.clone()
+    }
+}
+
+impl Resolved {
+    pub fn typecheck(&self) -> Result<Typed, TypeError> {
+        Ok(Typed(typecheck(&self.0)?))
+    }
+    pub fn typecheck_with(self, ty: &Normalized) -> Result<Typed, TypeError> {
+        Ok(Typed(typecheck_with(&self.0, ty.to_expr())?))
+    }
+    /// Converts a value back to the corresponding AST expression.
+    pub fn to_expr(&self) -> ResolvedExpr {
+        self.0.clone()
+    }
+}
+
+impl Typed {
+    /// Reduce an expression to its normal form, performing beta reduction
+    pub fn normalize(&self) -> Normalized {
+        Normalized(self.0.rec_eval_closed_expr())
+    }
+
+    /// Converts a value back to the corresponding AST expression.
+    fn to_expr(&self) -> ResolvedExpr {
+        self.0.to_expr(ToExprOptions {
+            alpha: false,
+            normalize: false,
+        })
+    }
+
+    pub(crate) fn get_type(&self) -> Result<Normalized, TypeError> {
+        Ok(Normalized(self.0.get_type()?))
+    }
+}
+
+impl Normalized {
+    pub fn encode(&self) -> Result<Vec<u8>, EncodeError> {
+        binary::encode(&self.to_expr())
+    }
+
+    /// Converts a value back to the corresponding AST expression.
+    pub fn to_expr(&self) -> NormalizedExpr {
+        self.0.to_expr(ToExprOptions {
+            alpha: false,
+            normalize: false,
+        })
+    }
+    /// Converts a value back to the corresponding AST expression, alpha-normalizing in the process.
+    pub(crate) fn to_expr_alpha(&self) -> NormalizedExpr {
+        self.0.to_expr(ToExprOptions {
+            alpha: true,
+            normalize: false,
+        })
+    }
+    pub(crate) fn to_value(&self) -> Value {
+        self.0.clone()
+    }
+    pub(crate) fn into_value(self) -> Value {
+        self.0
+    }
+
+    pub(crate) fn from_const(c: Const) -> Self {
+        Normalized(Value::from_const(c))
+    }
+    pub(crate) fn from_kind_and_type(
+        v: ValueKind<Value>,
+        t: Normalized,
+    ) -> Self {
+        Normalized(Value::from_kind_and_type(v, t.into_value()))
+    }
+    pub(crate) fn from_value(th: Value) -> Self {
+        Normalized(th)
+    }
+    pub(crate) fn const_type() -> Self {
+        Normalized::from_const(Const::Type)
+    }
+
+    pub fn make_builtin_type(b: Builtin) -> Self {
+        Normalized::from_value(Value::from_builtin(b))
+    }
+    pub fn make_optional_type(t: Normalized) -> Self {
+        Normalized::from_value(
+            Value::from_builtin(Builtin::Optional).app(t.to_value()),
+        )
+    }
+    pub fn make_list_type(t: Normalized) -> Self {
+        Normalized::from_value(
+            Value::from_builtin(Builtin::List).app(t.to_value()),
+        )
+    }
+    pub fn make_record_type(
+        kts: impl Iterator<Item = (String, Normalized)>,
+    ) -> Self {
+        Normalized::from_kind_and_type(
+            ValueKind::RecordType(
+                kts.map(|(k, t)| (k.into(), t.into_value())).collect(),
+            ),
+            Normalized::const_type(),
+        )
+    }
+    pub fn make_union_type(
+        kts: impl Iterator<Item = (String, Option<Normalized>)>,
+    ) -> Self {
+        Normalized::from_kind_and_type(
+            ValueKind::UnionType(
+                kts.map(|(k, t)| (k.into(), t.map(|t| t.into_value())))
+                    .collect(),
+            ),
+            Normalized::const_type(),
+        )
+    }
+}
+
+macro_rules! derive_traits_for_wrapper_struct {
+    ($ty:ident) => {
+        impl std::cmp::PartialEq for $ty {
+            fn eq(&self, other: &Self) -> bool {
+                self.0 == other.0
+            }
+        }
+
+        impl std::cmp::Eq for $ty {}
+
+        impl std::fmt::Display for $ty {
+            fn fmt(
+                &self,
+                f: &mut std::fmt::Formatter,
+            ) -> Result<(), std::fmt::Error> {
+                self.0.fmt(f)
+            }
+        }
+    };
+}
+
+derive_traits_for_wrapper_struct!(Parsed);
+derive_traits_for_wrapper_struct!(Resolved);
+
+impl std::hash::Hash for Normalized {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: std::hash::Hasher,
+    {
+        if let Ok(vec) = self.encode() {
+            vec.hash(state)
+        }
+    }
+}
+
+impl Eq for Typed {}
+impl PartialEq for Typed {
+    fn eq(&self, other: &Self) -> bool {
+        self.normalize() == other.normalize()
+    }
+}
+impl Display for Typed {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        self.to_expr().fmt(f)
+    }
+}
+
+impl Eq for Normalized {}
+impl PartialEq for Normalized {
+    fn eq(&self, other: &Self) -> bool {
+        self.0 == other.0
+    }
+}
+impl Display for Normalized {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        self.to_expr().fmt(f)
+    }
+}
diff --git a/dhall/src/semantics/builtins.rs b/dhall/src/semantics/builtins.rs
index 9d10d89..2211579 100644
--- a/dhall/src/semantics/builtins.rs
+++ b/dhall/src/semantics/builtins.rs
@@ -1,4 +1,3 @@
-use crate::semantics::phase::Normalized;
 use crate::semantics::{
     typecheck, NzEnv, TyExpr, TyExprKind, Value, ValueKind, VarEnv,
 };
@@ -8,6 +7,7 @@ use crate::syntax::{
     BinOp, Builtin, Const, Expr, ExprKind, InterpolatedText,
     InterpolatedTextContents, Label, NaiveDouble, Span, UnspannedExpr, V,
 };
+use crate::Normalized;
 use std::collections::HashMap;
 use std::convert::TryInto;
 
diff --git a/dhall/src/semantics/nze/normalize.rs b/dhall/src/semantics/nze/normalize.rs
index ea1a25b..6564018 100644
--- a/dhall/src/semantics/nze/normalize.rs
+++ b/dhall/src/semantics/nze/normalize.rs
@@ -1,6 +1,5 @@
 use std::collections::HashMap;
 
-use crate::semantics::phase::Normalized;
 use crate::semantics::NzEnv;
 use crate::semantics::{
     Binder, BuiltinClosure, Closure, TyExpr, TyExprKind, Value, ValueKind,
@@ -8,6 +7,7 @@ use crate::semantics::{
 use crate::syntax::{
     BinOp, Builtin, Const, ExprKind, InterpolatedTextContents,
 };
+use crate::Normalized;
 
 pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
     let f_borrow = f.kind();
diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index 215c342..0a9de6a 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -4,7 +4,6 @@ use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::nze::visitor;
-use crate::semantics::phase::{Normalized, NormalizedExpr, ToExprOptions};
 use crate::semantics::Binder;
 use crate::semantics::{apply_any, normalize_tyexpr_whnf, normalize_whnf};
 use crate::semantics::{type_of_builtin, typecheck, TyExpr, TyExprKind};
@@ -13,6 +12,7 @@ use crate::syntax::{
     BinOp, Builtin, Const, ExprKind, Integer, InterpolatedTextContents, Label,
     NaiveDouble, Natural, Span,
 };
+use crate::{Normalized, NormalizedExpr, ToExprOptions};
 
 use self::Form::{Unevaled, WHNF};
 
diff --git a/dhall/src/semantics/phase/mod.rs b/dhall/src/semantics/phase/mod.rs
index ff4b859..02e2b18 100644
--- a/dhall/src/semantics/phase/mod.rs
+++ b/dhall/src/semantics/phase/mod.rs
@@ -1,244 +1,2 @@
-use std::fmt::Display;
-use std::path::Path;
-
-use crate::error::{EncodeError, Error, ImportError, TypeError};
-use crate::semantics::{typecheck, typecheck_with, TyExpr, Value, ValueKind};
-use crate::syntax::binary;
-use crate::syntax::{Builtin, Const, Expr};
-use resolve::ImportRoot;
-
 pub(crate) mod parse;
 pub(crate) mod resolve;
-
-pub type ParsedExpr = Expr<Normalized>;
-pub type DecodedExpr = Expr<Normalized>;
-pub type ResolvedExpr = Expr<Normalized>;
-pub type NormalizedExpr = Expr<Normalized>;
-
-#[derive(Debug, Clone)]
-pub struct Parsed(ParsedExpr, ImportRoot);
-
-/// An expression where all imports have been resolved
-///
-/// Invariant: there must be no `Import` nodes or `ImportAlt` operations left.
-#[derive(Debug, Clone)]
-pub struct Resolved(ResolvedExpr);
-
-/// A typed expression
-#[derive(Debug, Clone)]
-pub struct Typed(TyExpr);
-
-/// A normalized expression.
-///
-/// Invariant: the contained Typed expression must be in normal form,
-#[derive(Debug, Clone)]
-pub struct Normalized(Value);
-
-/// Controls conversion from `Value` to `Expr`
-#[derive(Copy, Clone)]
-pub(crate) struct ToExprOptions {
-    /// Whether to convert all variables to `_`
-    pub(crate) alpha: bool,
-    /// Whether to normalize before converting
-    pub(crate) normalize: bool,
-}
-
-impl Parsed {
-    pub fn parse_file(f: &Path) -> Result<Parsed, Error> {
-        parse::parse_file(f)
-    }
-    pub fn parse_str(s: &str) -> Result<Parsed, Error> {
-        parse::parse_str(s)
-    }
-    pub fn parse_binary_file(f: &Path) -> Result<Parsed, Error> {
-        parse::parse_binary_file(f)
-    }
-    pub fn parse_binary(data: &[u8]) -> Result<Parsed, Error> {
-        parse::parse_binary(data)
-    }
-
-    pub fn resolve(self) -> Result<Resolved, ImportError> {
-        resolve::resolve(self)
-    }
-    pub fn skip_resolve(self) -> Result<Resolved, ImportError> {
-        resolve::skip_resolve_expr(self)
-    }
-
-    pub fn encode(&self) -> Result<Vec<u8>, EncodeError> {
-        binary::encode(&self.0)
-    }
-
-    /// Converts a value back to the corresponding AST expression.
-    pub fn to_expr(&self) -> ParsedExpr {
-        self.0.clone()
-    }
-}
-
-impl Resolved {
-    pub fn typecheck(&self) -> Result<Typed, TypeError> {
-        Ok(Typed(typecheck(&self.0)?))
-    }
-    pub fn typecheck_with(self, ty: &Normalized) -> Result<Typed, TypeError> {
-        Ok(Typed(typecheck_with(&self.0, ty.to_expr())?))
-    }
-    /// Converts a value back to the corresponding AST expression.
-    pub fn to_expr(&self) -> ResolvedExpr {
-        self.0.clone()
-    }
-}
-
-impl Typed {
-    /// Reduce an expression to its normal form, performing beta reduction
-    pub fn normalize(&self) -> Normalized {
-        Normalized(self.0.rec_eval_closed_expr())
-    }
-
-    /// Converts a value back to the corresponding AST expression.
-    fn to_expr(&self) -> ResolvedExpr {
-        self.0.to_expr(ToExprOptions {
-            alpha: false,
-            normalize: false,
-        })
-    }
-
-    pub(crate) fn get_type(&self) -> Result<Normalized, TypeError> {
-        Ok(Normalized(self.0.get_type()?))
-    }
-}
-
-impl Normalized {
-    pub fn encode(&self) -> Result<Vec<u8>, EncodeError> {
-        binary::encode(&self.to_expr())
-    }
-
-    /// Converts a value back to the corresponding AST expression.
-    pub fn to_expr(&self) -> NormalizedExpr {
-        self.0.to_expr(ToExprOptions {
-            alpha: false,
-            normalize: false,
-        })
-    }
-    /// Converts a value back to the corresponding AST expression, alpha-normalizing in the process.
-    pub(crate) fn to_expr_alpha(&self) -> NormalizedExpr {
-        self.0.to_expr(ToExprOptions {
-            alpha: true,
-            normalize: false,
-        })
-    }
-    pub(crate) fn to_value(&self) -> Value {
-        self.0.clone()
-    }
-    pub(crate) fn into_value(self) -> Value {
-        self.0
-    }
-
-    pub(crate) fn from_const(c: Const) -> Self {
-        Normalized(Value::from_const(c))
-    }
-    pub(crate) fn from_kind_and_type(
-        v: ValueKind<Value>,
-        t: Normalized,
-    ) -> Self {
-        Normalized(Value::from_kind_and_type(v, t.into_value()))
-    }
-    pub(crate) fn from_value(th: Value) -> Self {
-        Normalized(th)
-    }
-    pub(crate) fn const_type() -> Self {
-        Normalized::from_const(Const::Type)
-    }
-
-    pub fn make_builtin_type(b: Builtin) -> Self {
-        Normalized::from_value(Value::from_builtin(b))
-    }
-    pub fn make_optional_type(t: Normalized) -> Self {
-        Normalized::from_value(
-            Value::from_builtin(Builtin::Optional).app(t.to_value()),
-        )
-    }
-    pub fn make_list_type(t: Normalized) -> Self {
-        Normalized::from_value(
-            Value::from_builtin(Builtin::List).app(t.to_value()),
-        )
-    }
-    pub fn make_record_type(
-        kts: impl Iterator<Item = (String, Normalized)>,
-    ) -> Self {
-        Normalized::from_kind_and_type(
-            ValueKind::RecordType(
-                kts.map(|(k, t)| (k.into(), t.into_value())).collect(),
-            ),
-            Normalized::const_type(),
-        )
-    }
-    pub fn make_union_type(
-        kts: impl Iterator<Item = (String, Option<Normalized>)>,
-    ) -> Self {
-        Normalized::from_kind_and_type(
-            ValueKind::UnionType(
-                kts.map(|(k, t)| (k.into(), t.map(|t| t.into_value())))
-                    .collect(),
-            ),
-            Normalized::const_type(),
-        )
-    }
-}
-
-macro_rules! derive_traits_for_wrapper_struct {
-    ($ty:ident) => {
-        impl std::cmp::PartialEq for $ty {
-            fn eq(&self, other: &Self) -> bool {
-                self.0 == other.0
-            }
-        }
-
-        impl std::cmp::Eq for $ty {}
-
-        impl std::fmt::Display for $ty {
-            fn fmt(
-                &self,
-                f: &mut std::fmt::Formatter,
-            ) -> Result<(), std::fmt::Error> {
-                self.0.fmt(f)
-            }
-        }
-    };
-}
-
-derive_traits_for_wrapper_struct!(Parsed);
-derive_traits_for_wrapper_struct!(Resolved);
-
-impl std::hash::Hash for Normalized {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: std::hash::Hasher,
-    {
-        if let Ok(vec) = self.encode() {
-            vec.hash(state)
-        }
-    }
-}
-
-impl Eq for Typed {}
-impl PartialEq for Typed {
-    fn eq(&self, other: &Self) -> bool {
-        self.normalize() == other.normalize()
-    }
-}
-impl Display for Typed {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
-        self.to_expr().fmt(f)
-    }
-}
-
-impl Eq for Normalized {}
-impl PartialEq for Normalized {
-    fn eq(&self, other: &Self) -> bool {
-        self.0 == other.0
-    }
-}
-impl Display for Normalized {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
-        self.to_expr().fmt(f)
-    }
-}
diff --git a/dhall/src/semantics/phase/parse.rs b/dhall/src/semantics/phase/parse.rs
index 00db422..b72fe7f 100644
--- a/dhall/src/semantics/phase/parse.rs
+++ b/dhall/src/semantics/phase/parse.rs
@@ -4,9 +4,9 @@ use std::path::Path;
 
 use crate::error::Error;
 use crate::semantics::phase::resolve::ImportRoot;
-use crate::semantics::phase::Parsed;
 use crate::syntax::binary;
 use crate::syntax::parse_expr;
+use crate::Parsed;
 
 pub(crate) fn parse_file(f: &Path) -> Result<Parsed, Error> {
     let mut buffer = String::new();
diff --git a/dhall/src/semantics/phase/resolve.rs b/dhall/src/semantics/phase/resolve.rs
index cc4a024..3acf114 100644
--- a/dhall/src/semantics/phase/resolve.rs
+++ b/dhall/src/semantics/phase/resolve.rs
@@ -2,9 +2,9 @@ use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
 use crate::error::{Error, ImportError};
-use crate::semantics::phase::{Normalized, NormalizedExpr, Parsed, Resolved};
 use crate::syntax;
 use crate::syntax::{FilePath, ImportLocation, URL};
+use crate::{Normalized, NormalizedExpr, Parsed, Resolved};
 
 type Import = syntax::Import<NormalizedExpr>;
 
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index 98dc3f9..4b88048 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -1,9 +1,9 @@
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::normalize_tyexpr_whnf;
-use crate::semantics::phase::Normalized;
-use crate::semantics::phase::{NormalizedExpr, ToExprOptions};
 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;
 
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index 348471f..212e6e7 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -4,7 +4,6 @@ use std::collections::HashMap;
 
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::merge_maps;
-use crate::semantics::phase::Normalized;
 use crate::semantics::{
     type_of_builtin, Binder, BuiltinClosure, Closure, TyEnv, TyExpr,
     TyExprKind, Type, Value, ValueKind,
@@ -12,6 +11,7 @@ use crate::semantics::{
 use crate::syntax::{
     BinOp, Builtin, Const, Expr, ExprKind, InterpolatedTextContents, Span,
 };
+use crate::Normalized;
 
 fn type_of_recordtype<'a>(
     tys: impl Iterator<Item = Cow<'a, TyExpr>>,
diff --git a/dhall/src/syntax/binary/decode.rs b/dhall/src/syntax/binary/decode.rs
index c18deb5..52b699c 100644
--- a/dhall/src/syntax/binary/decode.rs
+++ b/dhall/src/syntax/binary/decode.rs
@@ -3,13 +3,13 @@ use serde_cbor::value::value as cbor;
 use std::iter::FromIterator;
 
 use crate::error::DecodeError;
-use crate::semantics::phase::DecodedExpr;
 use crate::syntax;
 use crate::syntax::{
     Expr, ExprKind, FilePath, FilePrefix, Hash, ImportLocation, ImportMode,
     Integer, InterpolatedText, Label, Natural, Scheme, Span, UnspannedExpr,
     URL, V,
 };
+use crate::DecodedExpr;
 
 pub(crate) fn decode(data: &[u8]) -> Result<DecodedExpr, DecodeError> {
     match serde_cbor::de::from_slice(data) {
diff --git a/dhall/src/syntax/text/parser.rs b/dhall/src/syntax/text/parser.rs
index 681d6dd..2ec63e2 100644
--- a/dhall/src/syntax/text/parser.rs
+++ b/dhall/src/syntax/text/parser.rs
@@ -5,7 +5,6 @@ use std::rc::Rc;
 
 use pest_consume::{match_nodes, Parser};
 
-use crate::semantics::phase::Normalized;
 use crate::syntax;
 use crate::syntax::map::{DupTreeMap, DupTreeSet};
 use crate::syntax::ExprKind::*;
@@ -14,6 +13,7 @@ use crate::syntax::{
     InterpolatedText, InterpolatedTextContents, Label, NaiveDouble, Natural,
     Scheme, Span, UnspannedExpr, URL, V,
 };
+use crate::Normalized;
 
 // This file consumes the parse tree generated by pest and turns it into
 // our own AST. All those custom macros should eventually moved into
diff --git a/dhall/src/tests.rs b/dhall/src/tests.rs
index 08feadf..8216243 100644
--- a/dhall/src/tests.rs
+++ b/dhall/src/tests.rs
@@ -48,7 +48,7 @@ use std::io::{Read, Write};
 use std::path::PathBuf;
 
 use crate::error::{Error, Result};
-use crate::semantics::phase::Parsed;
+use crate::Parsed;
 
 #[allow(dead_code)]
 #[derive(Clone)]
-- 
cgit v1.2.3


From 0a60a4a891cd8c527ecc3caf6502bd614118d59a Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 17:11:16 +0000
Subject: Move parser files to syntax/

---
 dhall/build.rs                              |   4 +-
 dhall/src/dhall.abnf                        |   1 -
 dhall/src/dhall.pest.visibility             | 189 ----------------------------
 dhall/src/syntax/text/dhall.abnf            |   1 +
 dhall/src/syntax/text/dhall.pest.visibility | 189 ++++++++++++++++++++++++++++
 5 files changed, 192 insertions(+), 192 deletions(-)
 delete mode 120000 dhall/src/dhall.abnf
 delete mode 100644 dhall/src/dhall.pest.visibility
 create mode 120000 dhall/src/syntax/text/dhall.abnf
 create mode 100644 dhall/src/syntax/text/dhall.pest.visibility

(limited to 'dhall')

diff --git a/dhall/build.rs b/dhall/build.rs
index cc94f5e..8992f22 100644
--- a/dhall/build.rs
+++ b/dhall/build.rs
@@ -387,8 +387,8 @@ fn generate_tests() -> std::io::Result<()> {
 
 fn convert_abnf_to_pest() -> std::io::Result<()> {
     let out_dir = env::var("OUT_DIR").unwrap();
-    let abnf_path = "src/dhall.abnf";
-    let visibility_path = "src/dhall.pest.visibility";
+    let abnf_path = "src/syntax/text/dhall.abnf";
+    let visibility_path = "src/syntax/text/dhall.pest.visibility";
     let grammar_path = Path::new(&out_dir).join("dhall.pest");
     println!("cargo:rerun-if-changed={}", abnf_path);
     println!("cargo:rerun-if-changed={}", visibility_path);
diff --git a/dhall/src/dhall.abnf b/dhall/src/dhall.abnf
deleted file mode 120000
index ce13b8e..0000000
--- a/dhall/src/dhall.abnf
+++ /dev/null
@@ -1 +0,0 @@
-../../dhall-lang/standard/dhall.abnf
\ No newline at end of file
diff --git a/dhall/src/dhall.pest.visibility b/dhall/src/dhall.pest.visibility
deleted file mode 100644
index 03a000b..0000000
--- a/dhall/src/dhall.pest.visibility
+++ /dev/null
@@ -1,189 +0,0 @@
-# end_of_line
-# valid_non_ascii
-# tab
-# block_comment
-# block_comment_char
-# block_comment_continue
-# not_end_of_line
-# line_comment
-# whitespace_chunk
-# whsp
-# whsp1
-# ALPHA
-# DIGIT
-# ALPHANUM
-# HEXDIG
-# simple_label_first_char
-# simple_label_next_char
-simple_label
-# quoted_label_char
-quoted_label
-# label
-# nonreserved_label
-# any_label
-any_label_or_some
-double_quote_chunk
-double_quote_escaped
-# unicode_escape
-# unicode_suffix
-# unbraced_escape
-# braced_codepoint
-# braced_escape
-double_quote_char
-double_quote_literal
-single_quote_continue
-escaped_quote_pair
-escaped_interpolation
-single_quote_char
-single_quote_literal
-# interpolation
-# text_literal
-if_
-# then
-# else_
-# let_
-# in_
-# as_
-# using
-merge
-missing
-# Infinity
-NaN
-Some_
-toMap
-assert
-# keyword
-builtin
-# Optional
-Text
-# List
-Location
-# Bool
-# True
-# False
-# None_
-# Natural
-# Integer
-# Double
-# Type
-# Kind
-# Sort
-# Natural_fold
-# Natural_build
-# Natural_isZero
-# Natural_even
-# Natural_odd
-# Natural_toInteger
-# Natural_show
-# Integer_toDouble
-# Integer_show
-# Natural_subtract
-# Double_show
-# List_build
-# List_fold
-# List_length
-# List_head
-# List_last
-# List_indexed
-# List_reverse
-# Optional_fold
-# Optional_build
-# Text_show
-combine
-combine_types
-equivalent
-prefer
-lambda
-forall
-arrow
-# complete
-# exponent
-numeric_double_literal
-minus_infinity_literal
-plus_infinity_literal
-# double_literal
-natural_literal
-integer_literal
-identifier
-variable
-# path_character
-# quoted_path_character
-unquoted_path_component
-quoted_path_component
-# path_component
-path
-local
-parent_path
-here_path
-home_path
-absolute_path
-scheme
-http_raw
-authority
-# userinfo
-# host
-# port
-# IP_literal
-# IPvFuture
-# IPv6address
-# h16
-# ls32
-# IPv4address
-# dec_octet
-# domain
-# domainlabel
-# pchar
-query
-# pct_encoded
-# unreserved
-# sub_delims
-http
-env
-bash_environment_variable
-posix_environment_variable
-posix_environment_variable_character
-# import_type
-hash
-import_hashed
-import
-expression
-# annotated_expression
-let_binding
-empty_list_literal
-operator_expression
-import_alt_expression
-or_expression
-plus_expression
-text_append_expression
-list_append_expression
-and_expression
-combine_expression
-prefer_expression
-combine_types_expression
-times_expression
-equal_expression
-not_equal_expression
-equivalent_expression
-application_expression
-first_application_expression
-# import_expression
-completion_expression
-selector_expression
-selector
-labels
-# type_selector
-primitive_expression
-# record_type_or_literal
-empty_record_literal
-empty_record_type
-non_empty_record_type_or_literal
-non_empty_record_type
-record_type_entry
-non_empty_record_literal
-record_literal_entry
-union_type
-empty_union_type
-# non_empty_union_type
-union_type_entry
-non_empty_list_literal
-# complete_expression
diff --git a/dhall/src/syntax/text/dhall.abnf b/dhall/src/syntax/text/dhall.abnf
new file mode 120000
index 0000000..4a95034
--- /dev/null
+++ b/dhall/src/syntax/text/dhall.abnf
@@ -0,0 +1 @@
+../../../../dhall-lang/standard/dhall.abnf
\ No newline at end of file
diff --git a/dhall/src/syntax/text/dhall.pest.visibility b/dhall/src/syntax/text/dhall.pest.visibility
new file mode 100644
index 0000000..03a000b
--- /dev/null
+++ b/dhall/src/syntax/text/dhall.pest.visibility
@@ -0,0 +1,189 @@
+# end_of_line
+# valid_non_ascii
+# tab
+# block_comment
+# block_comment_char
+# block_comment_continue
+# not_end_of_line
+# line_comment
+# whitespace_chunk
+# whsp
+# whsp1
+# ALPHA
+# DIGIT
+# ALPHANUM
+# HEXDIG
+# simple_label_first_char
+# simple_label_next_char
+simple_label
+# quoted_label_char
+quoted_label
+# label
+# nonreserved_label
+# any_label
+any_label_or_some
+double_quote_chunk
+double_quote_escaped
+# unicode_escape
+# unicode_suffix
+# unbraced_escape
+# braced_codepoint
+# braced_escape
+double_quote_char
+double_quote_literal
+single_quote_continue
+escaped_quote_pair
+escaped_interpolation
+single_quote_char
+single_quote_literal
+# interpolation
+# text_literal
+if_
+# then
+# else_
+# let_
+# in_
+# as_
+# using
+merge
+missing
+# Infinity
+NaN
+Some_
+toMap
+assert
+# keyword
+builtin
+# Optional
+Text
+# List
+Location
+# Bool
+# True
+# False
+# None_
+# Natural
+# Integer
+# Double
+# Type
+# Kind
+# Sort
+# Natural_fold
+# Natural_build
+# Natural_isZero
+# Natural_even
+# Natural_odd
+# Natural_toInteger
+# Natural_show
+# Integer_toDouble
+# Integer_show
+# Natural_subtract
+# Double_show
+# List_build
+# List_fold
+# List_length
+# List_head
+# List_last
+# List_indexed
+# List_reverse
+# Optional_fold
+# Optional_build
+# Text_show
+combine
+combine_types
+equivalent
+prefer
+lambda
+forall
+arrow
+# complete
+# exponent
+numeric_double_literal
+minus_infinity_literal
+plus_infinity_literal
+# double_literal
+natural_literal
+integer_literal
+identifier
+variable
+# path_character
+# quoted_path_character
+unquoted_path_component
+quoted_path_component
+# path_component
+path
+local
+parent_path
+here_path
+home_path
+absolute_path
+scheme
+http_raw
+authority
+# userinfo
+# host
+# port
+# IP_literal
+# IPvFuture
+# IPv6address
+# h16
+# ls32
+# IPv4address
+# dec_octet
+# domain
+# domainlabel
+# pchar
+query
+# pct_encoded
+# unreserved
+# sub_delims
+http
+env
+bash_environment_variable
+posix_environment_variable
+posix_environment_variable_character
+# import_type
+hash
+import_hashed
+import
+expression
+# annotated_expression
+let_binding
+empty_list_literal
+operator_expression
+import_alt_expression
+or_expression
+plus_expression
+text_append_expression
+list_append_expression
+and_expression
+combine_expression
+prefer_expression
+combine_types_expression
+times_expression
+equal_expression
+not_equal_expression
+equivalent_expression
+application_expression
+first_application_expression
+# import_expression
+completion_expression
+selector_expression
+selector
+labels
+# type_selector
+primitive_expression
+# record_type_or_literal
+empty_record_literal
+empty_record_type
+non_empty_record_type_or_literal
+non_empty_record_type
+record_type_entry
+non_empty_record_literal
+record_literal_entry
+union_type
+empty_union_type
+# non_empty_union_type
+union_type_entry
+non_empty_list_literal
+# complete_expression
-- 
cgit v1.2.3


From 8ff022fa2cec34bc1d46ac3655d0c3d228ef893c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 17:16:25 +0000
Subject: Move parse and resolve up a level

---
 dhall/src/error/mod.rs               |   2 +-
 dhall/src/lib.rs                     |   6 +-
 dhall/src/semantics/mod.rs           |   3 +-
 dhall/src/semantics/parse.rs         |  37 +++++++
 dhall/src/semantics/phase/mod.rs     |   2 -
 dhall/src/semantics/phase/parse.rs   |  37 -------
 dhall/src/semantics/phase/resolve.rs | 181 -----------------------------------
 dhall/src/semantics/resolve.rs       | 181 +++++++++++++++++++++++++++++++++++
 8 files changed, 224 insertions(+), 225 deletions(-)
 create mode 100644 dhall/src/semantics/parse.rs
 delete mode 100644 dhall/src/semantics/phase/mod.rs
 delete mode 100644 dhall/src/semantics/phase/parse.rs
 delete mode 100644 dhall/src/semantics/phase/resolve.rs
 create mode 100644 dhall/src/semantics/resolve.rs

(limited to 'dhall')

diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs
index 8991758..4df018d 100644
--- a/dhall/src/error/mod.rs
+++ b/dhall/src/error/mod.rs
@@ -1,6 +1,6 @@
 use std::io::Error as IOError;
 
-use crate::semantics::phase::resolve::ImportStack;
+use crate::semantics::resolve::ImportStack;
 use crate::semantics::Value;
 use crate::syntax::{Import, ParseError};
 use crate::NormalizedExpr;
diff --git a/dhall/src/lib.rs b/dhall/src/lib.rs
index cbf3ceb..e9f8aa3 100644
--- a/dhall/src/lib.rs
+++ b/dhall/src/lib.rs
@@ -21,9 +21,9 @@ use std::fmt::Display;
 use std::path::Path;
 
 use crate::error::{EncodeError, Error, ImportError, TypeError};
-use crate::semantics::phase::parse;
-use crate::semantics::phase::resolve;
-use crate::semantics::phase::resolve::ImportRoot;
+use crate::semantics::parse;
+use crate::semantics::resolve;
+use crate::semantics::resolve::ImportRoot;
 use crate::semantics::{typecheck, typecheck_with, TyExpr, Value, ValueKind};
 use crate::syntax::binary;
 use crate::syntax::{Builtin, Const, Expr};
diff --git a/dhall/src/semantics/mod.rs b/dhall/src/semantics/mod.rs
index 92e5912..98fdf5a 100644
--- a/dhall/src/semantics/mod.rs
+++ b/dhall/src/semantics/mod.rs
@@ -1,6 +1,7 @@
 pub mod builtins;
 pub mod nze;
-pub mod phase;
+pub mod parse;
+pub mod resolve;
 pub mod tck;
 pub(crate) use self::builtins::*;
 pub(crate) use self::nze::*;
diff --git a/dhall/src/semantics/parse.rs b/dhall/src/semantics/parse.rs
new file mode 100644
index 0000000..ee35536
--- /dev/null
+++ b/dhall/src/semantics/parse.rs
@@ -0,0 +1,37 @@
+use std::fs::File;
+use std::io::Read;
+use std::path::Path;
+
+use crate::error::Error;
+use crate::semantics::resolve::ImportRoot;
+use crate::syntax::binary;
+use crate::syntax::parse_expr;
+use crate::Parsed;
+
+pub(crate) fn parse_file(f: &Path) -> Result<Parsed, Error> {
+    let mut buffer = String::new();
+    File::open(f)?.read_to_string(&mut buffer)?;
+    let expr = parse_expr(&*buffer)?;
+    let root = ImportRoot::LocalDir(f.parent().unwrap().to_owned());
+    Ok(Parsed(expr, root))
+}
+
+pub(crate) fn parse_str(s: &str) -> Result<Parsed, Error> {
+    let expr = parse_expr(s)?;
+    let root = ImportRoot::LocalDir(std::env::current_dir()?);
+    Ok(Parsed(expr, root))
+}
+
+pub(crate) fn parse_binary(data: &[u8]) -> Result<Parsed, Error> {
+    let expr = binary::decode(data)?;
+    let root = ImportRoot::LocalDir(std::env::current_dir()?);
+    Ok(Parsed(expr, root))
+}
+
+pub(crate) fn parse_binary_file(f: &Path) -> Result<Parsed, Error> {
+    let mut buffer = Vec::new();
+    File::open(f)?.read_to_end(&mut buffer)?;
+    let expr = binary::decode(&buffer)?;
+    let root = ImportRoot::LocalDir(f.parent().unwrap().to_owned());
+    Ok(Parsed(expr, root))
+}
diff --git a/dhall/src/semantics/phase/mod.rs b/dhall/src/semantics/phase/mod.rs
deleted file mode 100644
index 02e2b18..0000000
--- a/dhall/src/semantics/phase/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub(crate) mod parse;
-pub(crate) mod resolve;
diff --git a/dhall/src/semantics/phase/parse.rs b/dhall/src/semantics/phase/parse.rs
deleted file mode 100644
index b72fe7f..0000000
--- a/dhall/src/semantics/phase/parse.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-use std::fs::File;
-use std::io::Read;
-use std::path::Path;
-
-use crate::error::Error;
-use crate::semantics::phase::resolve::ImportRoot;
-use crate::syntax::binary;
-use crate::syntax::parse_expr;
-use crate::Parsed;
-
-pub(crate) fn parse_file(f: &Path) -> Result<Parsed, Error> {
-    let mut buffer = String::new();
-    File::open(f)?.read_to_string(&mut buffer)?;
-    let expr = parse_expr(&*buffer)?;
-    let root = ImportRoot::LocalDir(f.parent().unwrap().to_owned());
-    Ok(Parsed(expr, root))
-}
-
-pub(crate) fn parse_str(s: &str) -> Result<Parsed, Error> {
-    let expr = parse_expr(s)?;
-    let root = ImportRoot::LocalDir(std::env::current_dir()?);
-    Ok(Parsed(expr, root))
-}
-
-pub(crate) fn parse_binary(data: &[u8]) -> Result<Parsed, Error> {
-    let expr = binary::decode(data)?;
-    let root = ImportRoot::LocalDir(std::env::current_dir()?);
-    Ok(Parsed(expr, root))
-}
-
-pub(crate) fn parse_binary_file(f: &Path) -> Result<Parsed, Error> {
-    let mut buffer = Vec::new();
-    File::open(f)?.read_to_end(&mut buffer)?;
-    let expr = binary::decode(&buffer)?;
-    let root = ImportRoot::LocalDir(f.parent().unwrap().to_owned());
-    Ok(Parsed(expr, root))
-}
diff --git a/dhall/src/semantics/phase/resolve.rs b/dhall/src/semantics/phase/resolve.rs
deleted file mode 100644
index 3acf114..0000000
--- a/dhall/src/semantics/phase/resolve.rs
+++ /dev/null
@@ -1,181 +0,0 @@
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
-
-use crate::error::{Error, ImportError};
-use crate::syntax;
-use crate::syntax::{FilePath, ImportLocation, URL};
-use crate::{Normalized, NormalizedExpr, Parsed, Resolved};
-
-type Import = syntax::Import<NormalizedExpr>;
-
-/// A root from which to resolve relative imports.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) enum ImportRoot {
-    LocalDir(PathBuf),
-}
-
-type ImportCache = HashMap<Import, Normalized>;
-
-pub(crate) type ImportStack = Vec<Import>;
-
-fn resolve_import(
-    import: &Import,
-    root: &ImportRoot,
-    import_cache: &mut ImportCache,
-    import_stack: &ImportStack,
-) -> Result<Normalized, ImportError> {
-    use self::ImportRoot::*;
-    use syntax::FilePrefix::*;
-    use syntax::ImportLocation::*;
-    let cwd = match root {
-        LocalDir(cwd) => cwd,
-    };
-    match &import.location {
-        Local(prefix, path) => {
-            let path_buf: PathBuf = path.file_path.iter().collect();
-            let path_buf = match prefix {
-                // TODO: fail gracefully
-                Parent => cwd.parent().unwrap().join(path_buf),
-                Here => cwd.join(path_buf),
-                _ => unimplemented!("{:?}", import),
-            };
-            Ok(load_import(&path_buf, import_cache, import_stack).map_err(
-                |e| ImportError::Recursive(import.clone(), Box::new(e)),
-            )?)
-        }
-        _ => unimplemented!("{:?}", import),
-    }
-}
-
-fn load_import(
-    f: &Path,
-    import_cache: &mut ImportCache,
-    import_stack: &ImportStack,
-) -> Result<Normalized, Error> {
-    Ok(
-        do_resolve_expr(Parsed::parse_file(f)?, import_cache, import_stack)?
-            .typecheck()?
-            .normalize(),
-    )
-}
-
-fn do_resolve_expr(
-    parsed: Parsed,
-    import_cache: &mut ImportCache,
-    import_stack: &ImportStack,
-) -> Result<Resolved, ImportError> {
-    let Parsed(mut expr, root) = parsed;
-    let mut resolve = |import: Import| -> Result<Normalized, ImportError> {
-        if import_stack.contains(&import) {
-            return Err(ImportError::ImportCycle(import_stack.clone(), import));
-        }
-        match import_cache.get(&import) {
-            Some(expr) => Ok(expr.clone()),
-            None => {
-                // Copy the import stack and push the current import
-                let mut import_stack = import_stack.clone();
-                import_stack.push(import.clone());
-
-                // Resolve the import recursively
-                let expr = resolve_import(
-                    &import,
-                    &root,
-                    import_cache,
-                    &import_stack,
-                )?;
-
-                // Add the import to the cache
-                import_cache.insert(import, expr.clone());
-                Ok(expr)
-            }
-        }
-    };
-    expr.traverse_resolve_mut(&mut resolve)?;
-    Ok(Resolved(expr))
-}
-
-pub(crate) fn resolve(e: Parsed) -> Result<Resolved, ImportError> {
-    do_resolve_expr(e, &mut HashMap::new(), &Vec::new())
-}
-
-pub(crate) fn skip_resolve_expr(
-    parsed: Parsed,
-) -> Result<Resolved, ImportError> {
-    let mut expr = parsed.0;
-    let mut resolve = |import: Import| -> Result<Normalized, ImportError> {
-        Err(ImportError::UnexpectedImport(import))
-    };
-    expr.traverse_resolve_mut(&mut resolve)?;
-    Ok(Resolved(expr))
-}
-
-pub trait Canonicalize {
-    fn canonicalize(&self) -> Self;
-}
-
-impl Canonicalize for FilePath {
-    fn canonicalize(&self) -> FilePath {
-        let mut file_path = Vec::new();
-        let mut file_path_components = self.file_path.clone().into_iter();
-
-        loop {
-            let component = file_path_components.next();
-            match component.as_ref() {
-                // ───────────────────
-                // canonicalize(ε) = ε
-                None => break,
-
-                // canonicalize(directory₀) = directory₁
-                // ───────────────────────────────────────
-                // canonicalize(directory₀/.) = directory₁
-                Some(c) if c == "." => continue,
-
-                Some(c) if c == ".." => match file_path_components.next() {
-                    // canonicalize(directory₀) = ε
-                    // ────────────────────────────
-                    // canonicalize(directory₀/..) = /..
-                    None => file_path.push("..".to_string()),
-
-                    // canonicalize(directory₀) = directory₁/..
-                    // ──────────────────────────────────────────────
-                    // canonicalize(directory₀/..) = directory₁/../..
-                    Some(ref c) if c == ".." => {
-                        file_path.push("..".to_string());
-                        file_path.push("..".to_string());
-                    }
-
-                    // canonicalize(directory₀) = directory₁/component
-                    // ───────────────────────────────────────────────  ; If "component" is not
-                    // canonicalize(directory₀/..) = directory₁         ; ".."
-                    Some(_) => continue,
-                },
-
-                // canonicalize(directory₀) = directory₁
-                // ─────────────────────────────────────────────────────────  ; If no other
-                // canonicalize(directory₀/component) = directory₁/component  ; rule matches
-                Some(c) => file_path.push(c.clone()),
-            }
-        }
-
-        FilePath { file_path }
-    }
-}
-
-impl<SE: Copy> Canonicalize for ImportLocation<SE> {
-    fn canonicalize(&self) -> ImportLocation<SE> {
-        match self {
-            ImportLocation::Local(prefix, file) => {
-                ImportLocation::Local(*prefix, file.canonicalize())
-            }
-            ImportLocation::Remote(url) => ImportLocation::Remote(URL {
-                scheme: url.scheme,
-                authority: url.authority.clone(),
-                path: url.path.canonicalize(),
-                query: url.query.clone(),
-                headers: url.headers.clone(),
-            }),
-            ImportLocation::Env(name) => ImportLocation::Env(name.to_string()),
-            ImportLocation::Missing => ImportLocation::Missing,
-        }
-    }
-}
diff --git a/dhall/src/semantics/resolve.rs b/dhall/src/semantics/resolve.rs
new file mode 100644
index 0000000..3acf114
--- /dev/null
+++ b/dhall/src/semantics/resolve.rs
@@ -0,0 +1,181 @@
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+
+use crate::error::{Error, ImportError};
+use crate::syntax;
+use crate::syntax::{FilePath, ImportLocation, URL};
+use crate::{Normalized, NormalizedExpr, Parsed, Resolved};
+
+type Import = syntax::Import<NormalizedExpr>;
+
+/// A root from which to resolve relative imports.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum ImportRoot {
+    LocalDir(PathBuf),
+}
+
+type ImportCache = HashMap<Import, Normalized>;
+
+pub(crate) type ImportStack = Vec<Import>;
+
+fn resolve_import(
+    import: &Import,
+    root: &ImportRoot,
+    import_cache: &mut ImportCache,
+    import_stack: &ImportStack,
+) -> Result<Normalized, ImportError> {
+    use self::ImportRoot::*;
+    use syntax::FilePrefix::*;
+    use syntax::ImportLocation::*;
+    let cwd = match root {
+        LocalDir(cwd) => cwd,
+    };
+    match &import.location {
+        Local(prefix, path) => {
+            let path_buf: PathBuf = path.file_path.iter().collect();
+            let path_buf = match prefix {
+                // TODO: fail gracefully
+                Parent => cwd.parent().unwrap().join(path_buf),
+                Here => cwd.join(path_buf),
+                _ => unimplemented!("{:?}", import),
+            };
+            Ok(load_import(&path_buf, import_cache, import_stack).map_err(
+                |e| ImportError::Recursive(import.clone(), Box::new(e)),
+            )?)
+        }
+        _ => unimplemented!("{:?}", import),
+    }
+}
+
+fn load_import(
+    f: &Path,
+    import_cache: &mut ImportCache,
+    import_stack: &ImportStack,
+) -> Result<Normalized, Error> {
+    Ok(
+        do_resolve_expr(Parsed::parse_file(f)?, import_cache, import_stack)?
+            .typecheck()?
+            .normalize(),
+    )
+}
+
+fn do_resolve_expr(
+    parsed: Parsed,
+    import_cache: &mut ImportCache,
+    import_stack: &ImportStack,
+) -> Result<Resolved, ImportError> {
+    let Parsed(mut expr, root) = parsed;
+    let mut resolve = |import: Import| -> Result<Normalized, ImportError> {
+        if import_stack.contains(&import) {
+            return Err(ImportError::ImportCycle(import_stack.clone(), import));
+        }
+        match import_cache.get(&import) {
+            Some(expr) => Ok(expr.clone()),
+            None => {
+                // Copy the import stack and push the current import
+                let mut import_stack = import_stack.clone();
+                import_stack.push(import.clone());
+
+                // Resolve the import recursively
+                let expr = resolve_import(
+                    &import,
+                    &root,
+                    import_cache,
+                    &import_stack,
+                )?;
+
+                // Add the import to the cache
+                import_cache.insert(import, expr.clone());
+                Ok(expr)
+            }
+        }
+    };
+    expr.traverse_resolve_mut(&mut resolve)?;
+    Ok(Resolved(expr))
+}
+
+pub(crate) fn resolve(e: Parsed) -> Result<Resolved, ImportError> {
+    do_resolve_expr(e, &mut HashMap::new(), &Vec::new())
+}
+
+pub(crate) fn skip_resolve_expr(
+    parsed: Parsed,
+) -> Result<Resolved, ImportError> {
+    let mut expr = parsed.0;
+    let mut resolve = |import: Import| -> Result<Normalized, ImportError> {
+        Err(ImportError::UnexpectedImport(import))
+    };
+    expr.traverse_resolve_mut(&mut resolve)?;
+    Ok(Resolved(expr))
+}
+
+pub trait Canonicalize {
+    fn canonicalize(&self) -> Self;
+}
+
+impl Canonicalize for FilePath {
+    fn canonicalize(&self) -> FilePath {
+        let mut file_path = Vec::new();
+        let mut file_path_components = self.file_path.clone().into_iter();
+
+        loop {
+            let component = file_path_components.next();
+            match component.as_ref() {
+                // ───────────────────
+                // canonicalize(ε) = ε
+                None => break,
+
+                // canonicalize(directory₀) = directory₁
+                // ───────────────────────────────────────
+                // canonicalize(directory₀/.) = directory₁
+                Some(c) if c == "." => continue,
+
+                Some(c) if c == ".." => match file_path_components.next() {
+                    // canonicalize(directory₀) = ε
+                    // ────────────────────────────
+                    // canonicalize(directory₀/..) = /..
+                    None => file_path.push("..".to_string()),
+
+                    // canonicalize(directory₀) = directory₁/..
+                    // ──────────────────────────────────────────────
+                    // canonicalize(directory₀/..) = directory₁/../..
+                    Some(ref c) if c == ".." => {
+                        file_path.push("..".to_string());
+                        file_path.push("..".to_string());
+                    }
+
+                    // canonicalize(directory₀) = directory₁/component
+                    // ───────────────────────────────────────────────  ; If "component" is not
+                    // canonicalize(directory₀/..) = directory₁         ; ".."
+                    Some(_) => continue,
+                },
+
+                // canonicalize(directory₀) = directory₁
+                // ─────────────────────────────────────────────────────────  ; If no other
+                // canonicalize(directory₀/component) = directory₁/component  ; rule matches
+                Some(c) => file_path.push(c.clone()),
+            }
+        }
+
+        FilePath { file_path }
+    }
+}
+
+impl<SE: Copy> Canonicalize for ImportLocation<SE> {
+    fn canonicalize(&self) -> ImportLocation<SE> {
+        match self {
+            ImportLocation::Local(prefix, file) => {
+                ImportLocation::Local(*prefix, file.canonicalize())
+            }
+            ImportLocation::Remote(url) => ImportLocation::Remote(URL {
+                scheme: url.scheme,
+                authority: url.authority.clone(),
+                path: url.path.canonicalize(),
+                query: url.query.clone(),
+                headers: url.headers.clone(),
+            }),
+            ImportLocation::Env(name) => ImportLocation::Env(name.to_string()),
+            ImportLocation::Missing => ImportLocation::Missing,
+        }
+    }
+}
-- 
cgit v1.2.3


From 7062de011eab7954f4bcf78fa1cf970ba91d6a5a Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 18:04:16 +0000
Subject: Remove Value visitor

It's mostly useful when we can change types, but it's also too
constraining if we can, because then we can't enforce complex invariants
like the one for TextLit.
---
 dhall/src/semantics/nze/mod.rs     |   1 -
 dhall/src/semantics/nze/value.rs   | 228 ++++++++++++++-----------------------
 dhall/src/semantics/nze/visitor.rs | 167 ---------------------------
 3 files changed, 87 insertions(+), 309 deletions(-)
 delete mode 100644 dhall/src/semantics/nze/visitor.rs

(limited to 'dhall')

diff --git a/dhall/src/semantics/nze/mod.rs b/dhall/src/semantics/nze/mod.rs
index e3b37cd..3d9c5eb 100644
--- a/dhall/src/semantics/nze/mod.rs
+++ b/dhall/src/semantics/nze/mod.rs
@@ -2,7 +2,6 @@ pub mod env;
 pub mod normalize;
 pub mod value;
 pub mod var;
-pub mod visitor;
 pub(crate) use env::*;
 pub(crate) use normalize::*;
 pub(crate) use value::*;
diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index 0a9de6a..6ab6fe3 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -3,7 +3,6 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
-use crate::semantics::nze::visitor;
 use crate::semantics::Binder;
 use crate::semantics::{apply_any, normalize_tyexpr_whnf, normalize_whnf};
 use crate::semantics::{type_of_builtin, typecheck, TyExpr, TyExprKind};
@@ -276,62 +275,96 @@ impl Value {
     }
 
     pub fn to_tyexpr(&self, venv: VarEnv) -> TyExpr {
+        let map_uniontype = |kts: &HashMap<Label, Option<Value>>| {
+            ExprKind::UnionType(
+                kts.iter()
+                    .map(|(k, v)| {
+                        (k.clone(), v.as_ref().map(|v| v.to_tyexpr(venv)))
+                    })
+                    .collect(),
+            )
+        };
+
         let tye = match &*self.kind() {
             ValueKind::Var(v) => TyExprKind::Var(venv.lookup(v)),
-            ValueKind::LamClosure {
-                binder,
-                annot,
-                closure,
-            } => TyExprKind::Expr(ExprKind::Lam(
-                binder.to_label(),
-                annot.to_tyexpr(venv),
-                closure.to_tyexpr(venv),
-            )),
-            ValueKind::PiClosure {
-                binder,
-                annot,
-                closure,
-            } => TyExprKind::Expr(ExprKind::Pi(
-                binder.to_label(),
-                annot.to_tyexpr(venv),
-                closure.to_tyexpr(venv),
-            )),
             ValueKind::AppliedBuiltin(closure) => closure.to_tyexprkind(venv),
-            ValueKind::UnionConstructor(l, kts, t) => {
-                TyExprKind::Expr(ExprKind::Field(
-                    TyExpr::new(
-                        TyExprKind::Expr(ExprKind::UnionType(
-                            kts.into_iter()
-                                .map(|(k, v)| {
-                                    (
-                                        k.clone(),
-                                        v.as_ref().map(|v| v.to_tyexpr(venv)),
-                                    )
-                                })
-                                .collect(),
+            ValueKind::Thunk(th) => return th.to_tyexpr(venv),
+            self_kind => TyExprKind::Expr(match self_kind {
+                ValueKind::Var(..)
+                | ValueKind::AppliedBuiltin(..)
+                | ValueKind::Thunk(..) => unreachable!(),
+                ValueKind::LamClosure {
+                    binder,
+                    annot,
+                    closure,
+                } => ExprKind::Lam(
+                    binder.to_label(),
+                    annot.to_tyexpr(venv),
+                    closure.to_tyexpr(venv),
+                ),
+                ValueKind::PiClosure {
+                    binder,
+                    annot,
+                    closure,
+                } => ExprKind::Pi(
+                    binder.to_label(),
+                    annot.to_tyexpr(venv),
+                    closure.to_tyexpr(venv),
+                ),
+                ValueKind::Const(c) => ExprKind::Const(*c),
+                ValueKind::BoolLit(b) => ExprKind::BoolLit(*b),
+                ValueKind::NaturalLit(n) => ExprKind::NaturalLit(*n),
+                ValueKind::IntegerLit(n) => ExprKind::IntegerLit(*n),
+                ValueKind::DoubleLit(n) => ExprKind::DoubleLit(*n),
+                ValueKind::EmptyOptionalLit(n) => ExprKind::App(
+                    Value::from_builtin(Builtin::OptionalNone).to_tyexpr(venv),
+                    n.to_tyexpr(venv),
+                ),
+                ValueKind::NEOptionalLit(n) => {
+                    ExprKind::SomeLit(n.to_tyexpr(venv))
+                }
+                ValueKind::EmptyListLit(n) => {
+                    ExprKind::EmptyListLit(TyExpr::new(
+                        TyExprKind::Expr(ExprKind::App(
+                            Value::from_builtin(Builtin::List).to_tyexpr(venv),
+                            n.to_tyexpr(venv),
                         )),
+                        Some(Value::from_const(Const::Type)),
+                        Span::Artificial,
+                    ))
+                }
+                ValueKind::NEListLit(elts) => ExprKind::NEListLit(
+                    elts.iter().map(|v| v.to_tyexpr(venv)).collect(),
+                ),
+                ValueKind::TextLit(elts) => ExprKind::TextLit(
+                    elts.iter()
+                        .map(|t| t.map_ref(|v| v.to_tyexpr(venv)))
+                        .collect(),
+                ),
+                ValueKind::RecordLit(kvs) => ExprKind::RecordLit(
+                    kvs.iter()
+                        .map(|(k, v)| (k.clone(), v.to_tyexpr(venv)))
+                        .collect(),
+                ),
+                ValueKind::RecordType(kts) => ExprKind::RecordType(
+                    kts.iter()
+                        .map(|(k, v)| (k.clone(), v.to_tyexpr(venv)))
+                        .collect(),
+                ),
+                ValueKind::UnionType(kts) => map_uniontype(kts),
+                ValueKind::UnionConstructor(l, kts, t) => ExprKind::Field(
+                    TyExpr::new(
+                        TyExprKind::Expr(map_uniontype(kts)),
                         Some(t.clone()),
                         Span::Artificial,
                     ),
                     l.clone(),
-                ))
-            }
-            ValueKind::UnionLit(l, v, kts, uniont, ctort) => {
-                TyExprKind::Expr(ExprKind::App(
+                ),
+                ValueKind::UnionLit(l, v, kts, uniont, ctort) => ExprKind::App(
                     TyExpr::new(
                         TyExprKind::Expr(ExprKind::Field(
                             TyExpr::new(
-                                TyExprKind::Expr(ExprKind::UnionType(
-                                    kts.into_iter()
-                                        .map(|(k, v)| {
-                                            (
-                                                k.clone(),
-                                                v.as_ref()
-                                                    .map(|v| v.to_tyexpr(venv)),
-                                            )
-                                        })
-                                        .collect(),
-                                )),
+                                TyExprKind::Expr(map_uniontype(kts)),
                                 Some(uniont.clone()),
                                 Span::Artificial,
                             ),
@@ -341,61 +374,14 @@ impl Value {
                         Span::Artificial,
                     ),
                     v.to_tyexpr(venv),
-                ))
-            }
-            ValueKind::Thunk(th) => return th.to_tyexpr(venv),
-            self_kind => {
-                let self_kind = self_kind.map_ref(|v| v.to_tyexpr(venv));
-                let expr = match self_kind {
-                    ValueKind::Var(..)
-                    | ValueKind::LamClosure { .. }
-                    | ValueKind::PiClosure { .. }
-                    | ValueKind::AppliedBuiltin(..)
-                    | ValueKind::UnionConstructor(..)
-                    | ValueKind::UnionLit(..)
-                    | ValueKind::Thunk(..) => unreachable!(),
-                    ValueKind::Const(c) => ExprKind::Const(c),
-                    ValueKind::BoolLit(b) => ExprKind::BoolLit(b),
-                    ValueKind::NaturalLit(n) => ExprKind::NaturalLit(n),
-                    ValueKind::IntegerLit(n) => ExprKind::IntegerLit(n),
-                    ValueKind::DoubleLit(n) => ExprKind::DoubleLit(n),
-                    ValueKind::EmptyOptionalLit(n) => ExprKind::App(
-                        Value::from_builtin(Builtin::OptionalNone)
-                            .to_tyexpr(venv),
-                        n,
-                    ),
-                    ValueKind::NEOptionalLit(n) => ExprKind::SomeLit(n),
-                    ValueKind::EmptyListLit(n) => {
-                        ExprKind::EmptyListLit(TyExpr::new(
-                            TyExprKind::Expr(ExprKind::App(
-                                Value::from_builtin(Builtin::List)
-                                    .to_tyexpr(venv),
-                                n,
-                            )),
-                            Some(Value::from_const(Const::Type)),
-                            Span::Artificial,
-                        ))
-                    }
-                    ValueKind::NEListLit(elts) => ExprKind::NEListLit(elts),
-                    ValueKind::RecordLit(kvs) => {
-                        ExprKind::RecordLit(kvs.into_iter().collect())
-                    }
-                    ValueKind::RecordType(kts) => {
-                        ExprKind::RecordType(kts.into_iter().collect())
-                    }
-                    ValueKind::UnionType(kts) => {
-                        ExprKind::UnionType(kts.into_iter().collect())
-                    }
-                    ValueKind::TextLit(elts) => {
-                        ExprKind::TextLit(elts.into_iter().collect())
-                    }
-                    ValueKind::Equivalence(x, y) => {
-                        ExprKind::BinOp(BinOp::Equivalence, x, y)
-                    }
-                    ValueKind::PartialExpr(e) => e,
-                };
-                TyExprKind::Expr(expr)
-            }
+                ),
+                ValueKind::Equivalence(x, y) => ExprKind::BinOp(
+                    BinOp::Equivalence,
+                    x.to_tyexpr(venv),
+                    y.to_tyexpr(venv),
+                ),
+                ValueKind::PartialExpr(e) => e.map_ref(|v| v.to_tyexpr(venv)),
+            }),
         };
 
         let self_ty = self.as_internal().ty.clone();
@@ -535,46 +521,6 @@ impl ValueKind<Value> {
     }
 }
 
-impl<V> ValueKind<V> {
-    fn traverse_ref_with_special_handling_of_binders<'a, V2, E>(
-        &'a self,
-        visit_val: impl FnMut(&'a V) -> Result<V2, E>,
-        visit_under_binder: impl for<'b> FnMut(
-            &'a Binder,
-            &'b V,
-            &'a V,
-        ) -> Result<V2, E>,
-    ) -> Result<ValueKind<V2>, E> {
-        use visitor::ValueKindVisitor;
-        visitor::TraverseRefWithBindersVisitor {
-            visit_val,
-            visit_under_binder,
-        }
-        .visit(self)
-    }
-
-    fn map_ref_with_special_handling_of_binders<'a, V2>(
-        &'a self,
-        mut map_val: impl FnMut(&'a V) -> V2,
-        mut map_under_binder: impl for<'b> FnMut(&'a Binder, &'b V, &'a V) -> V2,
-    ) -> ValueKind<V2> {
-        use crate::syntax::trivial_result;
-        trivial_result(self.traverse_ref_with_special_handling_of_binders(
-            |x| Ok(map_val(x)),
-            |l, t, x| Ok(map_under_binder(l, t, x)),
-        ))
-    }
-
-    fn map_ref<'a, V2>(
-        &'a self,
-        map_val: impl Fn(&'a V) -> V2,
-    ) -> ValueKind<V2> {
-        self.map_ref_with_special_handling_of_binders(&map_val, |_, _, x| {
-            map_val(x)
-        })
-    }
-}
-
 impl Thunk {
     pub fn new(env: &NzEnv, body: TyExpr) -> Self {
         Thunk {
diff --git a/dhall/src/semantics/nze/visitor.rs b/dhall/src/semantics/nze/visitor.rs
deleted file mode 100644
index d1a85d8..0000000
--- a/dhall/src/semantics/nze/visitor.rs
+++ /dev/null
@@ -1,167 +0,0 @@
-use std::iter::FromIterator;
-
-use crate::semantics::{Binder, BuiltinClosure, ValueKind};
-use crate::syntax::Label;
-
-/// A visitor trait that can be used to traverse `ValueKind`s. We need this pattern so that Rust lets
-/// us have as much mutability as we can. See the equivalent file in `crate::syntax` for more
-/// details.
-pub(crate) trait ValueKindVisitor<'a, V1, V2>: Sized {
-    type Error;
-
-    fn visit_val(&mut self, val: &'a V1) -> Result<V2, Self::Error>;
-    fn visit_binder(
-        mut self,
-        _label: &'a Binder,
-        ty: &'a V1,
-        val: &'a V1,
-    ) -> Result<(V2, V2), Self::Error> {
-        Ok((self.visit_val(ty)?, self.visit_val(val)?))
-    }
-    fn visit_vec(&mut self, x: &'a [V1]) -> Result<Vec<V2>, Self::Error> {
-        x.iter().map(|e| self.visit_val(e)).collect()
-    }
-    fn visit_opt(
-        &mut self,
-        x: &'a Option<V1>,
-    ) -> Result<Option<V2>, Self::Error> {
-        Ok(match x {
-            Some(x) => Some(self.visit_val(x)?),
-            None => None,
-        })
-    }
-    fn visit_map<T>(
-        &mut self,
-        x: impl IntoIterator<Item = (&'a Label, &'a V1)>,
-    ) -> Result<T, Self::Error>
-    where
-        V1: 'a,
-        T: FromIterator<(Label, V2)>,
-    {
-        x.into_iter()
-            .map(|(k, x)| Ok((k.clone(), self.visit_val(x)?)))
-            .collect()
-    }
-    fn visit_optmap<T>(
-        &mut self,
-        x: impl IntoIterator<Item = (&'a Label, &'a Option<V1>)>,
-    ) -> Result<T, Self::Error>
-    where
-        V1: 'a,
-        T: FromIterator<(Label, Option<V2>)>,
-    {
-        x.into_iter()
-            .map(|(k, x)| Ok((k.clone(), self.visit_opt(x)?)))
-            .collect()
-    }
-
-    fn visit(
-        self,
-        input: &'a ValueKind<V1>,
-    ) -> Result<ValueKind<V2>, Self::Error> {
-        visit_ref(self, input)
-    }
-}
-
-fn visit_ref<'a, Visitor, V1, V2>(
-    mut v: Visitor,
-    input: &'a ValueKind<V1>,
-) -> Result<ValueKind<V2>, Visitor::Error>
-where
-    Visitor: ValueKindVisitor<'a, V1, V2>,
-{
-    use ValueKind::*;
-    Ok(match input {
-        LamClosure {
-            binder,
-            annot,
-            closure,
-        } => LamClosure {
-            binder: binder.clone(),
-            annot: v.visit_val(annot)?,
-            closure: closure.clone(),
-        },
-        PiClosure {
-            binder,
-            annot,
-            closure,
-        } => PiClosure {
-            binder: binder.clone(),
-            annot: v.visit_val(annot)?,
-            closure: closure.clone(),
-        },
-        AppliedBuiltin(BuiltinClosure {
-            b,
-            args,
-            types,
-            env,
-        }) => AppliedBuiltin(BuiltinClosure {
-            b: *b,
-            args: v.visit_vec(args)?,
-            types: v.visit_vec(types)?,
-            env: env.clone(),
-        }),
-        Var(v) => Var(*v),
-        Const(k) => Const(*k),
-        BoolLit(b) => BoolLit(*b),
-        NaturalLit(n) => NaturalLit(*n),
-        IntegerLit(n) => IntegerLit(*n),
-        DoubleLit(n) => DoubleLit(*n),
-        EmptyOptionalLit(t) => EmptyOptionalLit(v.visit_val(t)?),
-        NEOptionalLit(x) => NEOptionalLit(v.visit_val(x)?),
-        EmptyListLit(t) => EmptyListLit(v.visit_val(t)?),
-        NEListLit(xs) => NEListLit(v.visit_vec(xs)?),
-        RecordType(kts) => RecordType(v.visit_map(kts)?),
-        RecordLit(kvs) => RecordLit(v.visit_map(kvs)?),
-        UnionType(kts) => UnionType(v.visit_optmap(kts)?),
-        UnionConstructor(l, kts, uniont) => UnionConstructor(
-            l.clone(),
-            v.visit_optmap(kts)?,
-            v.visit_val(uniont)?,
-        ),
-        UnionLit(l, x, kts, uniont, ctort) => UnionLit(
-            l.clone(),
-            v.visit_val(x)?,
-            v.visit_optmap(kts)?,
-            v.visit_val(uniont)?,
-            v.visit_val(ctort)?,
-        ),
-        TextLit(ts) => TextLit(
-            ts.iter()
-                .map(|t| t.traverse_ref(|e| v.visit_val(e)))
-                .collect::<Result<_, _>>()?,
-        ),
-        Equivalence(x, y) => Equivalence(v.visit_val(x)?, v.visit_val(y)?),
-        PartialExpr(e) => PartialExpr(e.traverse_ref(|e| v.visit_val(e))?),
-        Thunk(th) => Thunk(th.clone()),
-    })
-}
-
-pub struct TraverseRefWithBindersVisitor<F1, F2> {
-    pub visit_val: F1,
-    pub visit_under_binder: F2,
-}
-
-impl<'a, V1, V2, Err, F1, F2> ValueKindVisitor<'a, V1, V2>
-    for TraverseRefWithBindersVisitor<F1, F2>
-where
-    V1: 'a,
-    F1: FnMut(&'a V1) -> Result<V2, Err>,
-    F2: for<'b> FnOnce(&'a Binder, &'b V1, &'a V1) -> Result<V2, Err>,
-{
-    type Error = Err;
-
-    fn visit_val(&mut self, val: &'a V1) -> Result<V2, Self::Error> {
-        (self.visit_val)(val)
-    }
-    fn visit_binder<'b>(
-        mut self,
-        label: &'a Binder,
-        ty: &'a V1,
-        val: &'a V1,
-    ) -> Result<(V2, V2), Self::Error> {
-        let val = (self.visit_under_binder)(label, ty, val)?;
-        let ty = (self.visit_val)(ty)?;
-        Ok((ty, val))
-    }
-}
-- 
cgit v1.2.3


From 0749482ad2ab9340fb45a2fe2997d2ea04516d75 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 18:06:53 +0000
Subject: Remove type parameter from ValueKind

---
 dhall/src/lib.rs                     |  5 +----
 dhall/src/semantics/builtins.rs      | 13 ++++---------
 dhall/src/semantics/nze/normalize.rs | 11 ++++-------
 dhall/src/semantics/nze/value.rs     | 27 ++++++++++++---------------
 4 files changed, 21 insertions(+), 35 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/lib.rs b/dhall/src/lib.rs
index e9f8aa3..dbf1fc0 100644
--- a/dhall/src/lib.rs
+++ b/dhall/src/lib.rs
@@ -153,10 +153,7 @@ impl Normalized {
     pub(crate) fn from_const(c: Const) -> Self {
         Normalized(Value::from_const(c))
     }
-    pub(crate) fn from_kind_and_type(
-        v: ValueKind<Value>,
-        t: Normalized,
-    ) -> Self {
+    pub(crate) fn from_kind_and_type(v: ValueKind, t: Normalized) -> Self {
         Normalized(Value::from_kind_and_type(v, t.into_value()))
     }
     pub(crate) fn from_value(th: Value) -> Self {
diff --git a/dhall/src/semantics/builtins.rs b/dhall/src/semantics/builtins.rs
index 2211579..6dbe878 100644
--- a/dhall/src/semantics/builtins.rs
+++ b/dhall/src/semantics/builtins.rs
@@ -35,18 +35,13 @@ impl BuiltinClosure<Value> {
         }
     }
 
-    pub fn apply(
-        &self,
-        a: Value,
-        f_ty: Value,
-        ret_ty: &Value,
-    ) -> ValueKind<Value> {
+    pub fn apply(&self, a: Value, f_ty: Value, ret_ty: &Value) -> ValueKind {
         use std::iter::once;
         let args = self.args.iter().cloned().chain(once(a.clone())).collect();
         let types = self.types.iter().cloned().chain(once(f_ty)).collect();
         apply_builtin(self.b, args, ret_ty, types, self.env.clone())
     }
-    pub fn ensure_whnf(self, ret_ty: &Value) -> ValueKind<Value> {
+    pub fn ensure_whnf(self, ret_ty: &Value) -> ValueKind {
         apply_builtin(self.b, self.args, ret_ty, self.types, self.env)
     }
     pub fn normalize_mut(&mut self) {
@@ -276,13 +271,13 @@ fn apply_builtin(
     ty: &Value,
     types: Vec<Value>,
     env: NzEnv,
-) -> ValueKind<Value> {
+) -> ValueKind {
     use Builtin::*;
     use ValueKind::*;
 
     // Small helper enum
     enum Ret {
-        ValueKind(ValueKind<Value>),
+        ValueKind(ValueKind),
         Value(Value),
         DoneAsIs,
     }
diff --git a/dhall/src/semantics/nze/normalize.rs b/dhall/src/semantics/nze/normalize.rs
index 6564018..90036e3 100644
--- a/dhall/src/semantics/nze/normalize.rs
+++ b/dhall/src/semantics/nze/normalize.rs
@@ -9,7 +9,7 @@ use crate::syntax::{
 };
 use crate::Normalized;
 
-pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind<Value> {
+pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind {
     let f_borrow = f.kind();
     match &*f_borrow {
         ValueKind::LamClosure { closure, .. } => {
@@ -102,7 +102,7 @@ where
 
 // Small helper enum to avoid repetition
 enum Ret<'a> {
-    ValueKind(ValueKind<Value>),
+    ValueKind(ValueKind),
     Value(Value),
     ValueRef(&'a Value),
     Expr(ExprKind<Value, Normalized>),
@@ -255,7 +255,7 @@ pub(crate) fn normalize_one_layer(
     expr: ExprKind<Value, Normalized>,
     ty: &Value,
     env: &NzEnv,
-) -> ValueKind<Value> {
+) -> ValueKind {
     use ValueKind::{
         BoolLit, DoubleLit, EmptyOptionalLit, IntegerLit, NEListLit,
         NEOptionalLit, NaturalLit, RecordLit, RecordType, TextLit,
@@ -450,10 +450,7 @@ pub(crate) fn normalize_one_layer(
 }
 
 /// Normalize a ValueKind into WHNF
-pub(crate) fn normalize_whnf(
-    v: ValueKind<Value>,
-    ty: &Value,
-) -> ValueKind<Value> {
+pub(crate) fn normalize_whnf(v: ValueKind, ty: &Value) -> ValueKind {
     match v {
         ValueKind::AppliedBuiltin(closure) => closure.ensure_whnf(ty),
         ValueKind::PartialExpr(e) => normalize_one_layer(e, ty, &NzEnv::new()),
diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index 6ab6fe3..8fad911 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -28,7 +28,7 @@ pub(crate) struct Value(Rc<RefCell<ValueInternal>>);
 #[derive(Debug)]
 struct ValueInternal {
     form: Form,
-    kind: ValueKind<Value>,
+    kind: ValueKind,
     /// This is None if and only if `value` is `Sort` (which doesn't have a type)
     ty: Option<Value>,
     span: Span,
@@ -68,7 +68,7 @@ pub(crate) enum Closure {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) enum ValueKind<Value> {
+pub(crate) enum ValueKind {
     /// Closures
     LamClosure {
         binder: Binder,
@@ -112,7 +112,7 @@ pub(crate) enum ValueKind<Value> {
 }
 
 impl Value {
-    fn new(kind: ValueKind<Value>, form: Form, ty: Value, span: Span) -> Value {
+    fn new(kind: ValueKind, form: Form, ty: Value, span: Span) -> Value {
         ValueInternal {
             form,
             kind,
@@ -139,13 +139,10 @@ impl Value {
         }
         .into_value()
     }
-    pub(crate) fn from_kind_and_type(v: ValueKind<Value>, t: Value) -> Value {
+    pub(crate) fn from_kind_and_type(v: ValueKind, t: Value) -> Value {
         Value::new(v, Unevaled, t, Span::Artificial)
     }
-    pub(crate) fn from_kind_and_type_whnf(
-        v: ValueKind<Value>,
-        t: Value,
-    ) -> Value {
+    pub(crate) fn from_kind_and_type_whnf(v: ValueKind, t: Value) -> Value {
         Value::new(v, WHNF, t, Span::Artificial)
     }
     pub(crate) fn from_const(c: Const) -> Self {
@@ -189,7 +186,7 @@ impl Value {
     /// This is what you want if you want to pattern-match on the value.
     /// WARNING: drop this ref before normalizing the same value or you will run into BorrowMut
     /// panics.
-    pub(crate) fn kind(&self) -> Ref<ValueKind<Value>> {
+    pub(crate) fn kind(&self) -> Ref<ValueKind> {
         self.normalize_whnf();
         Ref::map(self.as_internal(), ValueInternal::as_kind)
     }
@@ -202,11 +199,11 @@ impl Value {
 
         self.to_tyexpr_noenv().to_expr(opts)
     }
-    pub(crate) fn to_whnf_ignore_type(&self) -> ValueKind<Value> {
+    pub(crate) fn to_whnf_ignore_type(&self) -> ValueKind {
         self.kind().clone()
     }
     /// Before discarding type information, check that it matches the expected return type.
-    pub(crate) fn to_whnf_check_type(&self, ty: &Value) -> ValueKind<Value> {
+    pub(crate) fn to_whnf_check_type(&self, ty: &Value) -> ValueKind {
         self.check_type(ty);
         self.to_whnf_ignore_type()
     }
@@ -397,7 +394,7 @@ impl ValueInternal {
     fn into_value(self) -> Value {
         Value(Rc::new(RefCell::new(self)))
     }
-    fn as_kind(&self) -> &ValueKind<Value> {
+    fn as_kind(&self) -> &ValueKind {
         &self.kind
     }
 
@@ -442,7 +439,7 @@ impl ValueInternal {
     }
 }
 
-impl ValueKind<Value> {
+impl ValueKind {
     pub(crate) fn into_value_with_type(self, t: Value) -> Value {
         Value::from_kind_and_type(self, t)
     }
@@ -513,10 +510,10 @@ impl ValueKind<Value> {
         }
     }
 
-    pub(crate) fn from_builtin(b: Builtin) -> ValueKind<Value> {
+    pub(crate) fn from_builtin(b: Builtin) -> ValueKind {
         ValueKind::from_builtin_env(b, NzEnv::new())
     }
-    pub(crate) fn from_builtin_env(b: Builtin, env: NzEnv) -> ValueKind<Value> {
+    pub(crate) fn from_builtin_env(b: Builtin, env: NzEnv) -> ValueKind {
         ValueKind::AppliedBuiltin(BuiltinClosure::new(b, env))
     }
 }
-- 
cgit v1.2.3


From dc01ef2030e1177e4f247f4ddc0a3f69241d5cfc Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 18:32:22 +0000
Subject: Factor out text literals in Value

This allows encapsulating invariants properly and reducing clutter
---
 dhall/src/semantics/builtins.rs      | 67 +++++++++++---------------------
 dhall/src/semantics/nze/normalize.rs | 52 +++++++++++--------------
 dhall/src/semantics/nze/value.rs     | 74 +++++++++++++++++++++++++++++++-----
 3 files changed, 110 insertions(+), 83 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/builtins.rs b/dhall/src/semantics/builtins.rs
index 6dbe878..1357adf 100644
--- a/dhall/src/semantics/builtins.rs
+++ b/dhall/src/semantics/builtins.rs
@@ -1,5 +1,5 @@
 use crate::semantics::{
-    typecheck, NzEnv, TyExpr, TyExprKind, Value, ValueKind, VarEnv,
+    self, typecheck, NzEnv, TyExpr, TyExprKind, Value, ValueKind, VarEnv,
 };
 use crate::syntax::map::DupTreeMap;
 use crate::syntax::Const::Type;
@@ -301,14 +301,12 @@ fn apply_builtin(
             NaturalLit(n) => Ret::ValueKind(IntegerLit(*n as isize)),
             _ => Ret::DoneAsIs,
         },
-        (NaturalShow, [n]) => {
-            match &*n.kind() {
-                NaturalLit(n) => Ret::ValueKind(TextLit(vec![
-                    InterpolatedTextContents::Text(n.to_string()),
-                ])),
-                _ => Ret::DoneAsIs,
-            }
-        }
+        (NaturalShow, [n]) => match &*n.kind() {
+            NaturalLit(n) => Ret::ValueKind(TextLit(
+                semantics::TextLit::from_text(n.to_string()),
+            )),
+            _ => Ret::DoneAsIs,
+        },
         (NaturalSubtract, [a, b]) => match (&*a.kind(), &*b.kind()) {
             (NaturalLit(a), NaturalLit(b)) => {
                 Ret::ValueKind(NaturalLit(if b > a { b - a } else { 0 }))
@@ -325,7 +323,7 @@ fn apply_builtin(
                 } else {
                     format!("+{}", n)
                 };
-                Ret::ValueKind(TextLit(vec![InterpolatedTextContents::Text(s)]))
+                Ret::ValueKind(TextLit(semantics::TextLit::from_text(s)))
             }
             _ => Ret::DoneAsIs,
         },
@@ -345,42 +343,23 @@ fn apply_builtin(
             }
             _ => Ret::DoneAsIs,
         },
-        (DoubleShow, [n]) => {
-            match &*n.kind() {
-                DoubleLit(n) => Ret::ValueKind(TextLit(vec![
-                    InterpolatedTextContents::Text(n.to_string()),
-                ])),
-                _ => Ret::DoneAsIs,
-            }
-        }
+        (DoubleShow, [n]) => match &*n.kind() {
+            DoubleLit(n) => Ret::ValueKind(TextLit(
+                semantics::TextLit::from_text(n.to_string()),
+            )),
+            _ => Ret::DoneAsIs,
+        },
         (TextShow, [v]) => match &*v.kind() {
-            TextLit(elts) => {
-                match elts.as_slice() {
-                    // Empty string literal.
-                    [] => {
-                        // Printing InterpolatedText takes care of all the escaping
-                        let txt: InterpolatedText<Normalized> =
-                            std::iter::empty().collect();
-                        let s = txt.to_string();
-                        Ret::ValueKind(TextLit(vec![
-                            InterpolatedTextContents::Text(s),
-                        ]))
-                    }
-                    // If there are no interpolations (invariants ensure that when there are no
-                    // interpolations, there is a single Text item) in the literal.
-                    [InterpolatedTextContents::Text(s)] => {
-                        // Printing InterpolatedText takes care of all the escaping
-                        let txt: InterpolatedText<Normalized> =
-                            std::iter::once(InterpolatedTextContents::Text(
-                                s.clone(),
-                            ))
+            TextLit(tlit) => {
+                if let Some(s) = tlit.as_text() {
+                    // Printing InterpolatedText takes care of all the escaping
+                    let txt: InterpolatedText<Normalized> =
+                        std::iter::once(InterpolatedTextContents::Text(s))
                             .collect();
-                        let s = txt.to_string();
-                        Ret::ValueKind(TextLit(vec![
-                            InterpolatedTextContents::Text(s),
-                        ]))
-                    }
-                    _ => Ret::DoneAsIs,
+                    let s = txt.to_string();
+                    Ret::ValueKind(TextLit(semantics::TextLit::from_text(s)))
+                } else {
+                    Ret::DoneAsIs
                 }
             }
             _ => Ret::DoneAsIs,
diff --git a/dhall/src/semantics/nze/normalize.rs b/dhall/src/semantics/nze/normalize.rs
index 90036e3..89424e9 100644
--- a/dhall/src/semantics/nze/normalize.rs
+++ b/dhall/src/semantics/nze/normalize.rs
@@ -2,7 +2,8 @@ use std::collections::HashMap;
 
 use crate::semantics::NzEnv;
 use crate::semantics::{
-    Binder, BuiltinClosure, Closure, TyExpr, TyExprKind, Value, ValueKind,
+    Binder, BuiltinClosure, Closure, TextLit, TyExpr, TyExprKind, Value,
+    ValueKind,
 };
 use crate::syntax::{
     BinOp, Builtin, Const, ExprKind, InterpolatedTextContents,
@@ -121,7 +122,6 @@ fn apply_binop<'a>(
     };
     use ValueKind::{
         BoolLit, EmptyListLit, NEListLit, NaturalLit, RecordLit, RecordType,
-        TextLit,
     };
     let x_borrow = x.kind();
     let y_borrow = y.kind();
@@ -164,25 +164,21 @@ fn apply_binop<'a>(
             NEListLit(xs.iter().chain(ys.iter()).cloned().collect()),
         ),
 
-        (TextAppend, TextLit(x), _) if x.is_empty() => Ret::ValueRef(y),
-        (TextAppend, _, TextLit(y)) if y.is_empty() => Ret::ValueRef(x),
-        (TextAppend, TextLit(x), TextLit(y)) => Ret::ValueKind(TextLit(
-            squash_textlit(x.iter().chain(y.iter()).cloned()),
-        )),
-        (TextAppend, TextLit(x), _) => {
-            use std::iter::once;
-            let y = InterpolatedTextContents::Expr(y.clone());
-            Ret::ValueKind(TextLit(squash_textlit(
-                x.iter().cloned().chain(once(y)),
-            )))
-        }
-        (TextAppend, _, TextLit(y)) => {
-            use std::iter::once;
-            let x = InterpolatedTextContents::Expr(x.clone());
-            Ret::ValueKind(TextLit(squash_textlit(
-                once(x).chain(y.iter().cloned()),
-            )))
+        (TextAppend, ValueKind::TextLit(x), _) if x.is_empty() => {
+            Ret::ValueRef(y)
+        }
+        (TextAppend, _, ValueKind::TextLit(y)) if y.is_empty() => {
+            Ret::ValueRef(x)
+        }
+        (TextAppend, ValueKind::TextLit(x), ValueKind::TextLit(y)) => {
+            Ret::ValueKind(ValueKind::TextLit(x.concat(y)))
         }
+        (TextAppend, ValueKind::TextLit(x), _) => Ret::ValueKind(
+            ValueKind::TextLit(x.concat(&TextLit::interpolate(y.clone()))),
+        ),
+        (TextAppend, _, ValueKind::TextLit(y)) => Ret::ValueKind(
+            ValueKind::TextLit(TextLit::interpolate(x.clone()).concat(y)),
+        ),
 
         (RightBiasedRecordMerge, _, RecordLit(kvs)) if kvs.is_empty() => {
             Ret::ValueRef(x)
@@ -258,8 +254,8 @@ pub(crate) fn normalize_one_layer(
 ) -> ValueKind {
     use ValueKind::{
         BoolLit, DoubleLit, EmptyOptionalLit, IntegerLit, NEListLit,
-        NEOptionalLit, NaturalLit, RecordLit, RecordType, TextLit,
-        UnionConstructor, UnionLit, UnionType,
+        NEOptionalLit, NaturalLit, RecordLit, RecordType, UnionConstructor,
+        UnionLit, UnionType,
     };
 
     let ret = match expr {
@@ -309,13 +305,12 @@ pub(crate) fn normalize_one_layer(
             Ret::ValueKind(UnionType(kvs.into_iter().collect()))
         }
         ExprKind::TextLit(elts) => {
-            use InterpolatedTextContents::Expr;
-            let elts: Vec<_> = squash_textlit(elts.into_iter());
+            let tlit = TextLit::new(elts.into_iter());
             // Simplify bare interpolation
-            if let [Expr(th)] = elts.as_slice() {
-                Ret::Value(th.clone())
+            if let Some(v) = tlit.as_single_expr() {
+                Ret::Value(v.clone())
             } else {
-                Ret::ValueKind(TextLit(elts))
+                Ret::ValueKind(ValueKind::TextLit(tlit))
             }
         }
         ExprKind::BoolIf(ref b, ref e1, ref e2) => {
@@ -455,9 +450,6 @@ pub(crate) fn normalize_whnf(v: ValueKind, ty: &Value) -> ValueKind {
         ValueKind::AppliedBuiltin(closure) => closure.ensure_whnf(ty),
         ValueKind::PartialExpr(e) => normalize_one_layer(e, ty, &NzEnv::new()),
         ValueKind::Thunk(th) => th.eval().kind().clone(),
-        ValueKind::TextLit(elts) => {
-            ValueKind::TextLit(squash_textlit(elts.into_iter()))
-        }
         // All other cases are already in WHNF
         v => v,
     }
diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index 8fad911..06d8df8 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -4,7 +4,9 @@ use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::Binder;
-use crate::semantics::{apply_any, normalize_tyexpr_whnf, normalize_whnf};
+use crate::semantics::{
+    apply_any, normalize_tyexpr_whnf, normalize_whnf, squash_textlit,
+};
 use crate::semantics::{type_of_builtin, typecheck, TyExpr, TyExprKind};
 use crate::semantics::{BuiltinClosure, NzEnv, NzVar, VarEnv};
 use crate::syntax::{
@@ -67,6 +69,12 @@ pub(crate) enum Closure {
     ConstantClosure { env: NzEnv, body: TyExpr },
 }
 
+/// A text literal with interpolations.
+// Invariant: this must not contain interpolations that are themselves TextLits, and contiguous
+// text values must be merged.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct TextLit(Vec<InterpolatedTextContents<Value>>);
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum ValueKind {
     /// Closures
@@ -101,9 +109,7 @@ pub(crate) enum ValueKind {
     UnionConstructor(Label, HashMap<Label, Option<Value>>, Value),
     // Also keep the type of the uniontype and the constructor around
     UnionLit(Label, Value, HashMap<Label, Option<Value>>, Value, Value),
-    // Invariant: in whnf, this must not contain interpolations that are themselves TextLits, and
-    // contiguous text values must be merged.
-    TextLit(Vec<InterpolatedTextContents<Value>>),
+    TextLit(TextLit),
     Equivalence(Value, Value),
     // Invariant: in whnf, this must not contain a value captured by one of the variants above.
     PartialExpr(ExprKind<Value, Normalized>),
@@ -492,11 +498,7 @@ impl ValueKind {
                     x.normalize_mut();
                 }
             }
-            ValueKind::TextLit(elts) => {
-                for x in elts.iter_mut() {
-                    x.map_mut(Value::normalize_mut);
-                }
-            }
+            ValueKind::TextLit(tlit) => tlit.normalize_mut(),
             ValueKind::Equivalence(x, y) => {
                 x.normalize_mut();
                 y.normalize_mut();
@@ -594,6 +596,60 @@ impl Closure {
     }
 }
 
+impl TextLit {
+    pub fn new(
+        elts: impl Iterator<Item = InterpolatedTextContents<Value>>,
+    ) -> Self {
+        TextLit(squash_textlit(elts))
+    }
+    pub fn interpolate(v: Value) -> TextLit {
+        TextLit(vec![InterpolatedTextContents::Expr(v)])
+    }
+    pub fn from_text(s: String) -> TextLit {
+        TextLit(vec![InterpolatedTextContents::Text(s)])
+    }
+
+    pub fn concat(&self, other: &TextLit) -> TextLit {
+        TextLit::new(self.iter().chain(other.iter()).cloned())
+    }
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+    /// If the literal consists of only one interpolation and not text, return the interpolated
+    /// value.
+    pub fn as_single_expr(&self) -> Option<&Value> {
+        use InterpolatedTextContents::Expr;
+        if let [Expr(v)] = self.0.as_slice() {
+            Some(v)
+        } else {
+            None
+        }
+    }
+    /// If there are no interpolations, return the corresponding text value.
+    pub fn as_text(&self) -> Option<String> {
+        use InterpolatedTextContents::Text;
+        if self.is_empty() {
+            Some(String::new())
+        } else if let [Text(s)] = self.0.as_slice() {
+            Some(s.clone())
+        } else {
+            None
+        }
+    }
+    pub fn iter(
+        &self,
+    ) -> impl Iterator<Item = &InterpolatedTextContents<Value>> {
+        self.0.iter()
+    }
+    /// Normalize the contained values. This does not break the invariant because we have already
+    /// ensured that no contained values normalize to a TextLit.
+    pub fn normalize_mut(&mut self) {
+        for x in self.0.iter_mut() {
+            x.map_mut(Value::normalize_mut);
+        }
+    }
+}
+
 /// Compare two values for equality modulo alpha/beta-equivalence.
 // TODO: use Rc comparison to shortcut on identical pointers
 impl std::cmp::PartialEq for Value {
-- 
cgit v1.2.3


From 3c4895a06a4910184203d8531e7ab318db71fb15 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 19:13:37 +0000
Subject: Prepare ValueInternal with new `Form`s

---
 dhall/src/semantics/nze/value.rs | 103 +++++++++++++++++++--------------------
 1 file changed, 50 insertions(+), 53 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index 06d8df8..31acb11 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -30,23 +30,22 @@ pub(crate) struct Value(Rc<RefCell<ValueInternal>>);
 #[derive(Debug)]
 struct ValueInternal {
     form: Form,
-    kind: ValueKind,
     /// This is None if and only if `value` is `Sort` (which doesn't have a type)
     ty: Option<Value>,
     span: Span,
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 pub(crate) enum Form {
     /// No constraints; expression may not be normalized at all.
-    Unevaled,
+    Unevaled(ValueKind),
     /// Weak Head Normal Form, i.e. normalized up to the first constructor, but subexpressions may
     /// not be normalized. This means that the first constructor of the contained ValueKind is the first
     /// constructor of the final Normal Form (NF).
     /// When all the Values in a ValueKind are in WHNF, and recursively so, then the
     /// ValueKind is in NF. This is because WHNF ensures that we have the first constructor of the NF; so
     /// if we have the first constructor of the NF at all levels, we actually have the NF.
-    WHNF,
+    WHNF(ValueKind),
 }
 
 /// An unevaluated subexpression
@@ -118,10 +117,9 @@ pub(crate) enum ValueKind {
 }
 
 impl Value {
-    fn new(kind: ValueKind, form: Form, ty: Value, span: Span) -> Value {
+    fn new(form: Form, ty: Value, span: Span) -> Value {
         ValueInternal {
             form,
-            kind,
             ty: Some(ty),
             span,
         }
@@ -129,8 +127,7 @@ impl Value {
     }
     pub(crate) fn const_sort() -> Value {
         ValueInternal {
-            form: WHNF,
-            kind: ValueKind::Const(Const::Sort),
+            form: WHNF(ValueKind::Const(Const::Sort)),
             ty: None,
             span: Span::Artificial,
         }
@@ -138,18 +135,17 @@ impl Value {
     }
     pub(crate) fn new_thunk(env: &NzEnv, tye: TyExpr) -> Value {
         ValueInternal {
-            form: Unevaled,
-            kind: ValueKind::Thunk(Thunk::new(env, tye.clone())),
+            form: Unevaled(ValueKind::Thunk(Thunk::new(env, tye.clone()))),
             ty: tye.get_type().ok(),
             span: tye.span().clone(),
         }
         .into_value()
     }
     pub(crate) fn from_kind_and_type(v: ValueKind, t: Value) -> Value {
-        Value::new(v, Unevaled, t, Span::Artificial)
+        Value::new(Unevaled(v), t, Span::Artificial)
     }
     pub(crate) fn from_kind_and_type_whnf(v: ValueKind, t: Value) -> Value {
-        Value::new(v, WHNF, t, Span::Artificial)
+        Value::new(WHNF(v), t, Span::Artificial)
     }
     pub(crate) fn from_const(c: Const) -> Self {
         let v = ValueKind::Const(c);
@@ -194,7 +190,10 @@ impl Value {
     /// panics.
     pub(crate) fn kind(&self) -> Ref<ValueKind> {
         self.normalize_whnf();
-        Ref::map(self.as_internal(), ValueInternal::as_kind)
+        Ref::map(self.as_internal(), |vint| match &vint.form {
+            Unevaled(..) => unreachable!(),
+            WHNF(k) => k,
+        })
     }
 
     /// Converts a value back to the corresponding AST expression.
@@ -232,12 +231,12 @@ impl Value {
     pub(crate) fn normalize_whnf(&self) {
         let borrow = self.as_internal();
         match borrow.form {
-            Unevaled => {
+            Unevaled(_) => {
                 drop(borrow);
                 self.as_internal_mut().normalize_whnf();
             }
             // Already in WHNF
-            WHNF => {}
+            WHNF(_) => {}
         }
     }
     pub(crate) fn normalize_nf(&self) {
@@ -400,41 +399,29 @@ impl ValueInternal {
     fn into_value(self) -> Value {
         Value(Rc::new(RefCell::new(self)))
     }
-    fn as_kind(&self) -> &ValueKind {
-        &self.kind
-    }
 
     fn normalize_whnf(&mut self) {
-        let dummy = ValueInternal {
-            form: Unevaled,
-            kind: ValueKind::Const(Const::Type),
-            ty: None,
-            span: Span::Artificial,
-        };
-        let vint = std::mem::replace(self, dummy);
-        *self = match (&vint.form, &vint.ty) {
-            (Unevaled, Some(ty)) => ValueInternal {
-                form: WHNF,
-                kind: normalize_whnf(vint.kind, &ty),
-                ty: vint.ty,
-                span: vint.span,
-            },
-            // `value` is `Sort`
-            (Unevaled, None) => ValueInternal {
-                form: WHNF,
-                kind: ValueKind::Const(Const::Sort),
-                ty: None,
-                span: vint.span,
-            },
+        use std::mem::replace;
+        let dummy = Unevaled(ValueKind::Const(Const::Type));
+        self.form = match replace(&mut self.form, dummy) {
+            Unevaled(kind) => {
+                WHNF(match &self.ty {
+                    Some(ty) => normalize_whnf(kind, &ty),
+                    // `value` is `Sort`
+                    None => ValueKind::Const(Const::Sort),
+                })
+            }
             // Already in WHNF
-            (WHNF, _) => vint,
-        }
+            form @ WHNF(_) => form,
+        };
     }
     fn normalize_nf(&mut self) {
-        if let Unevaled = self.form {
+        if let Unevaled(_) = self.form {
             self.normalize_whnf();
         }
-        self.kind.normalize_mut();
+        match &mut self.form {
+            Unevaled(k) | WHNF(k) => k.normalize_mut(),
+        }
     }
 
     fn get_type(&self) -> Result<&Value, TypeError> {
@@ -679,17 +666,27 @@ impl std::cmp::Eq for Closure {}
 impl std::fmt::Debug for Value {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let vint: &ValueInternal = &self.as_internal();
-        if let ValueKind::Const(c) = &vint.kind {
-            write!(fmt, "{:?}", c)
-        } else {
-            let mut x = fmt.debug_struct(&format!("Value@{:?}", &vint.form));
-            x.field("value", &vint.kind);
-            if let Some(ty) = vint.ty.as_ref() {
-                x.field("type", &ty);
-            } else {
-                x.field("type", &None::<()>);
+        let mut x = match &vint.form {
+            WHNF(kind) => {
+                if let ValueKind::Const(c) = kind {
+                    return write!(fmt, "{:?}", c);
+                } else {
+                    let mut x = fmt.debug_struct(&format!("Value@WHNF"));
+                    x.field("kind", kind);
+                    x
+                }
             }
-            x.finish()
+            Unevaled(kind) => {
+                let mut x = fmt.debug_struct(&format!("Value@Unevaled"));
+                x.field("kind", kind);
+                x
+            }
+        };
+        if let Some(ty) = vint.ty.as_ref() {
+            x.field("type", &ty);
+        } else {
+            x.field("type", &None::<()>);
         }
+        x.finish()
     }
 }
-- 
cgit v1.2.3


From 40336a928dfc3d1f96273d39ba564334b1719344 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 19:27:33 +0000
Subject: Move Thunk value into ValueInternal

---
 dhall/src/semantics/nze/normalize.rs |  1 -
 dhall/src/semantics/nze/value.rs     | 66 +++++++++++++++++-------------------
 2 files changed, 32 insertions(+), 35 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/nze/normalize.rs b/dhall/src/semantics/nze/normalize.rs
index 89424e9..16c886e 100644
--- a/dhall/src/semantics/nze/normalize.rs
+++ b/dhall/src/semantics/nze/normalize.rs
@@ -449,7 +449,6 @@ pub(crate) fn normalize_whnf(v: ValueKind, ty: &Value) -> ValueKind {
     match v {
         ValueKind::AppliedBuiltin(closure) => closure.ensure_whnf(ty),
         ValueKind::PartialExpr(e) => normalize_one_layer(e, ty, &NzEnv::new()),
-        ValueKind::Thunk(th) => th.eval().kind().clone(),
         // All other cases are already in WHNF
         v => v,
     }
diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index 31acb11..8ae0939 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -15,8 +15,6 @@ use crate::syntax::{
 };
 use crate::{Normalized, NormalizedExpr, ToExprOptions};
 
-use self::Form::{Unevaled, WHNF};
-
 /// Stores a possibly unevaluated value. Gets (partially) normalized on-demand, sharing computation
 /// automatically. Uses a RefCell to share computation.
 /// Can optionally store a type from typechecking to preserve type information.
@@ -37,6 +35,7 @@ struct ValueInternal {
 
 #[derive(Debug, Clone)]
 pub(crate) enum Form {
+    Thunk(Thunk),
     /// No constraints; expression may not be normalized at all.
     Unevaled(ValueKind),
     /// Weak Head Normal Form, i.e. normalized up to the first constructor, but subexpressions may
@@ -112,8 +111,6 @@ pub(crate) enum ValueKind {
     Equivalence(Value, Value),
     // Invariant: in whnf, this must not contain a value captured by one of the variants above.
     PartialExpr(ExprKind<Value, Normalized>),
-    // Invariant: absent in whnf
-    Thunk(Thunk),
 }
 
 impl Value {
@@ -127,7 +124,7 @@ impl Value {
     }
     pub(crate) fn const_sort() -> Value {
         ValueInternal {
-            form: WHNF(ValueKind::Const(Const::Sort)),
+            form: Form::WHNF(ValueKind::Const(Const::Sort)),
             ty: None,
             span: Span::Artificial,
         }
@@ -135,17 +132,17 @@ impl Value {
     }
     pub(crate) fn new_thunk(env: &NzEnv, tye: TyExpr) -> Value {
         ValueInternal {
-            form: Unevaled(ValueKind::Thunk(Thunk::new(env, tye.clone()))),
+            form: Form::Thunk(Thunk::new(env, tye.clone())),
             ty: tye.get_type().ok(),
             span: tye.span().clone(),
         }
         .into_value()
     }
     pub(crate) fn from_kind_and_type(v: ValueKind, t: Value) -> Value {
-        Value::new(Unevaled(v), t, Span::Artificial)
+        Value::new(Form::Unevaled(v), t, Span::Artificial)
     }
     pub(crate) fn from_kind_and_type_whnf(v: ValueKind, t: Value) -> Value {
-        Value::new(WHNF(v), t, Span::Artificial)
+        Value::new(Form::WHNF(v), t, Span::Artificial)
     }
     pub(crate) fn from_const(c: Const) -> Self {
         let v = ValueKind::Const(c);
@@ -191,8 +188,8 @@ impl Value {
     pub(crate) fn kind(&self) -> Ref<ValueKind> {
         self.normalize_whnf();
         Ref::map(self.as_internal(), |vint| match &vint.form {
-            Unevaled(..) => unreachable!(),
-            WHNF(k) => k,
+            Form::Thunk(..) | Form::Unevaled(..) => unreachable!(),
+            Form::WHNF(k) => k,
         })
     }
 
@@ -231,12 +228,12 @@ impl Value {
     pub(crate) fn normalize_whnf(&self) {
         let borrow = self.as_internal();
         match borrow.form {
-            Unevaled(_) => {
+            Form::Thunk(..) | Form::Unevaled(_) => {
                 drop(borrow);
                 self.as_internal_mut().normalize_whnf();
             }
             // Already in WHNF
-            WHNF(_) => {}
+            Form::WHNF(_) => {}
         }
     }
     pub(crate) fn normalize_nf(&self) {
@@ -290,11 +287,10 @@ impl Value {
         let tye = match &*self.kind() {
             ValueKind::Var(v) => TyExprKind::Var(venv.lookup(v)),
             ValueKind::AppliedBuiltin(closure) => closure.to_tyexprkind(venv),
-            ValueKind::Thunk(th) => return th.to_tyexpr(venv),
             self_kind => TyExprKind::Expr(match self_kind {
-                ValueKind::Var(..)
-                | ValueKind::AppliedBuiltin(..)
-                | ValueKind::Thunk(..) => unreachable!(),
+                ValueKind::Var(..) | ValueKind::AppliedBuiltin(..) => {
+                    unreachable!()
+                }
                 ValueKind::LamClosure {
                     binder,
                     annot,
@@ -402,25 +398,27 @@ impl ValueInternal {
 
     fn normalize_whnf(&mut self) {
         use std::mem::replace;
-        let dummy = Unevaled(ValueKind::Const(Const::Type));
+        let dummy = Form::Unevaled(ValueKind::Const(Const::Type));
         self.form = match replace(&mut self.form, dummy) {
-            Unevaled(kind) => {
-                WHNF(match &self.ty {
+            Form::Thunk(th) => Form::WHNF(th.eval().kind().clone()),
+            Form::Unevaled(kind) => {
+                Form::WHNF(match &self.ty {
                     Some(ty) => normalize_whnf(kind, &ty),
                     // `value` is `Sort`
                     None => ValueKind::Const(Const::Sort),
                 })
             }
             // Already in WHNF
-            form @ WHNF(_) => form,
+            form @ Form::WHNF(_) => form,
         };
     }
     fn normalize_nf(&mut self) {
-        if let Unevaled(_) = self.form {
+        if let Form::Thunk(..) | Form::Unevaled(_) = self.form {
             self.normalize_whnf();
         }
         match &mut self.form {
-            Unevaled(k) | WHNF(k) => k.normalize_mut(),
+            Form::Thunk(..) | Form::Unevaled(_) => unreachable!(),
+            Form::WHNF(k) => k.normalize_mut(),
         }
     }
 
@@ -493,9 +491,6 @@ impl ValueKind {
             ValueKind::PartialExpr(e) => {
                 e.map_mut(Value::normalize_mut);
             }
-            ValueKind::Thunk(..) => {
-                unreachable!("Should only normalize_mut values in WHNF")
-            }
         }
     }
 
@@ -515,12 +510,10 @@ impl Thunk {
         }
     }
 
+    // TODO: maybe return a ValueKind ?
     pub fn eval(&self) -> Value {
         normalize_tyexpr_whnf(&self.body, &self.env)
     }
-    pub fn to_tyexpr(&self, venv: VarEnv) -> TyExpr {
-        self.eval().to_tyexpr(venv)
-    }
 }
 
 impl Closure {
@@ -667,7 +660,17 @@ impl std::fmt::Debug for Value {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let vint: &ValueInternal = &self.as_internal();
         let mut x = match &vint.form {
-            WHNF(kind) => {
+            Form::Thunk(th) => {
+                let mut x = fmt.debug_struct(&format!("Value@Thunk"));
+                x.field("thunk", th);
+                x
+            }
+            Form::Unevaled(kind) => {
+                let mut x = fmt.debug_struct(&format!("Value@Unevaled"));
+                x.field("kind", kind);
+                x
+            }
+            Form::WHNF(kind) => {
                 if let ValueKind::Const(c) = kind {
                     return write!(fmt, "{:?}", c);
                 } else {
@@ -676,11 +679,6 @@ impl std::fmt::Debug for Value {
                     x
                 }
             }
-            Unevaled(kind) => {
-                let mut x = fmt.debug_struct(&format!("Value@Unevaled"));
-                x.field("kind", kind);
-                x
-            }
         };
         if let Some(ty) = vint.ty.as_ref() {
             x.field("type", &ty);
-- 
cgit v1.2.3


From 673a580e11d31356bec25d73213b283685fd6ea3 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 19:49:03 +0000
Subject: Clarify normalization to ensure we only nze once

---
 dhall/src/semantics/builtins.rs      |  7 ++--
 dhall/src/semantics/nze/env.rs       |  2 +-
 dhall/src/semantics/nze/normalize.rs | 25 ++++--------
 dhall/src/semantics/nze/value.rs     | 79 ++++++++++++++++++++----------------
 4 files changed, 55 insertions(+), 58 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/builtins.rs b/dhall/src/semantics/builtins.rs
index 1357adf..85ef294 100644
--- a/dhall/src/semantics/builtins.rs
+++ b/dhall/src/semantics/builtins.rs
@@ -12,7 +12,7 @@ use std::collections::HashMap;
 use std::convert::TryInto;
 
 /// A partially applied builtin.
-/// Invariant: TODO
+/// Invariant: the evaluation of the given args must not be able to progress further
 #[derive(Debug, Clone)]
 pub(crate) struct BuiltinClosure<Value> {
     pub env: NzEnv,
@@ -41,9 +41,8 @@ impl BuiltinClosure<Value> {
         let types = self.types.iter().cloned().chain(once(f_ty)).collect();
         apply_builtin(self.b, args, ret_ty, types, self.env.clone())
     }
-    pub fn ensure_whnf(self, ret_ty: &Value) -> ValueKind {
-        apply_builtin(self.b, self.args, ret_ty, self.types, self.env)
-    }
+    /// This doesn't break the invariant because we already checked that the appropriate arguments
+    /// did not normalize to something that allows evaluation to proceed.
     pub fn normalize_mut(&mut self) {
         for x in self.args.iter_mut() {
             x.normalize_mut();
diff --git a/dhall/src/semantics/nze/env.rs b/dhall/src/semantics/nze/env.rs
index a083076..073886e 100644
--- a/dhall/src/semantics/nze/env.rs
+++ b/dhall/src/semantics/nze/env.rs
@@ -62,7 +62,7 @@ impl NzEnv {
     pub fn lookup_val(&self, var: &AlphaVar) -> Value {
         let idx = self.items.len() - 1 - var.idx();
         match &self.items[idx] {
-            NzEnvItem::Kept(ty) => Value::from_kind_and_type_whnf(
+            NzEnvItem::Kept(ty) => Value::from_kind_and_type(
                 ValueKind::Var(NzVar::new(idx)),
                 ty.clone(),
             ),
diff --git a/dhall/src/semantics/nze/normalize.rs b/dhall/src/semantics/nze/normalize.rs
index 16c886e..7632d12 100644
--- a/dhall/src/semantics/nze/normalize.rs
+++ b/dhall/src/semantics/nze/normalize.rs
@@ -208,12 +208,12 @@ fn apply_binop<'a>(
                 _ => unreachable!("Internal type error"),
             };
             let kvs = merge_maps::<_, _, _, !>(kvs1, kvs2, |k, v1, v2| {
-                Ok(Value::from_kind_and_type(
-                    ValueKind::PartialExpr(ExprKind::BinOp(
+                Ok(Value::from_partial_expr(
+                    ExprKind::BinOp(
                         RecursiveRecordMerge,
                         v1.clone(),
                         v2.clone(),
-                    )),
+                    ),
                     kts.get(k).expect("Internal type error").clone(),
                 ))
             })?;
@@ -226,12 +226,12 @@ fn apply_binop<'a>(
                 kts_y,
                 // If the Label exists for both records, then we hit the recursive case.
                 |_, l: &Value, r: &Value| {
-                    Ok(Value::from_kind_and_type(
-                        ValueKind::PartialExpr(ExprKind::BinOp(
+                    Ok(Value::from_partial_expr(
+                        ExprKind::BinOp(
                             RecursiveRecordTypeMerge,
                             l.clone(),
                             r.clone(),
-                        )),
+                        ),
                         ty.clone(),
                     ))
                 },
@@ -444,16 +444,6 @@ pub(crate) fn normalize_one_layer(
     }
 }
 
-/// Normalize a ValueKind into WHNF
-pub(crate) fn normalize_whnf(v: ValueKind, ty: &Value) -> ValueKind {
-    match v {
-        ValueKind::AppliedBuiltin(closure) => closure.ensure_whnf(ty),
-        ValueKind::PartialExpr(e) => normalize_one_layer(e, ty, &NzEnv::new()),
-        // All other cases are already in WHNF
-        v => v,
-    }
-}
-
 /// Normalize a TyExpr into WHNF
 pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> Value {
     let ty = match tye.get_type() {
@@ -490,6 +480,5 @@ pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> Value {
         }
     };
 
-    // dbg!(tye.kind(), env, &kind);
-    Value::from_kind_and_type_whnf(kind, ty)
+    Value::from_kind_and_type(kind, ty)
 }
diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index 8ae0939..108dc9c 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -5,7 +5,7 @@ use std::rc::Rc;
 use crate::error::{TypeError, TypeMessage};
 use crate::semantics::Binder;
 use crate::semantics::{
-    apply_any, normalize_tyexpr_whnf, normalize_whnf, squash_textlit,
+    apply_any, normalize_one_layer, normalize_tyexpr_whnf, squash_textlit,
 };
 use crate::semantics::{type_of_builtin, typecheck, TyExpr, TyExprKind};
 use crate::semantics::{BuiltinClosure, NzEnv, NzVar, VarEnv};
@@ -16,34 +16,30 @@ use crate::syntax::{
 use crate::{Normalized, NormalizedExpr, ToExprOptions};
 
 /// Stores a possibly unevaluated value. Gets (partially) normalized on-demand, sharing computation
-/// automatically. Uses a RefCell to share computation.
-/// Can optionally store a type from typechecking to preserve type information.
-/// If you compare for equality two `Value`s in WHNF, then equality will be up to alpha-equivalence
+/// automatically. Uses a Rc<RefCell> to share computation.
+/// If you compare for equality two `Value`s, then equality will be up to alpha-equivalence
 /// (renaming of bound variables) and beta-equivalence (normalization). It will recursively
 /// normalize as needed.
 #[derive(Clone)]
 pub(crate) struct Value(Rc<RefCell<ValueInternal>>);
 
-/// Invariant: if `form` is `WHNF`, `value` must be in Weak Head Normal Form
 #[derive(Debug)]
 struct ValueInternal {
     form: Form,
-    /// This is None if and only if `value` is `Sort` (which doesn't have a type)
+    /// This is None if and only if `form` is `Sort` (which doesn't have a type)
     ty: Option<Value>,
     span: Span,
 }
 
+/// A potentially un-evaluated expression. Once we get to WHNF we won't modify the form again, as
+/// explained in the doc for `ValueKind`.
 #[derive(Debug, Clone)]
 pub(crate) enum Form {
+    /// A totally unnormalized value.
     Thunk(Thunk),
-    /// No constraints; expression may not be normalized at all.
-    Unevaled(ValueKind),
-    /// Weak Head Normal Form, i.e. normalized up to the first constructor, but subexpressions may
-    /// not be normalized. This means that the first constructor of the contained ValueKind is the first
-    /// constructor of the final Normal Form (NF).
-    /// When all the Values in a ValueKind are in WHNF, and recursively so, then the
-    /// ValueKind is in NF. This is because WHNF ensures that we have the first constructor of the NF; so
-    /// if we have the first constructor of the NF at all levels, we actually have the NF.
+    /// A partially normalized value that may need to go through `normalize_one_layer`.
+    PartialExpr(ExprKind<Value, Normalized>),
+    /// A value in WHNF.
     WHNF(ValueKind),
 }
 
@@ -73,6 +69,13 @@ pub(crate) enum Closure {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct TextLit(Vec<InterpolatedTextContents<Value>>);
 
+/// This represents a value in Weak Head Normal Form (WHNF). This means that the value is
+/// normalized up to the first constructor, but subexpressions may not be fully normalized.
+/// When all the Values in a ValueKind are in WHNF, and recursively so, then the ValueKind is in
+/// Normal Form (NF). This is because WHNF ensures that we have the first constructor of the NF; so
+/// if we have the first constructor of the NF at all levels, we actually have the NF.
+/// In particular, this means that once we get a `ValueKind`, it can be considered immutable, and
+/// we only need to recursively normalize its sub-`Value`s to get to the NF.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum ValueKind {
     /// Closures
@@ -86,7 +89,6 @@ pub(crate) enum ValueKind {
         annot: Value,
         closure: Closure,
     },
-    // Invariant: in whnf, the evaluation must not be able to progress further.
     AppliedBuiltin(BuiltinClosure<Value>),
 
     Var(NzVar),
@@ -109,7 +111,7 @@ pub(crate) enum ValueKind {
     UnionLit(Label, Value, HashMap<Label, Option<Value>>, Value, Value),
     TextLit(TextLit),
     Equivalence(Value, Value),
-    // Invariant: in whnf, this must not contain a value captured by one of the variants above.
+    /// Invariant: evaluation must not be able to progress with `normalize_one_layer`?
     PartialExpr(ExprKind<Value, Normalized>),
 }
 
@@ -130,6 +132,7 @@ impl Value {
         }
         .into_value()
     }
+    /// Construct a Value from a completely unnormalized expression.
     pub(crate) fn new_thunk(env: &NzEnv, tye: TyExpr) -> Value {
         ValueInternal {
             form: Form::Thunk(Thunk::new(env, tye.clone())),
@@ -138,10 +141,15 @@ impl Value {
         }
         .into_value()
     }
-    pub(crate) fn from_kind_and_type(v: ValueKind, t: Value) -> Value {
-        Value::new(Form::Unevaled(v), t, Span::Artificial)
+    /// Construct a Value from a partially normalized expression that's not in WHNF.
+    pub(crate) fn from_partial_expr(
+        e: ExprKind<Value, Normalized>,
+        t: Value,
+    ) -> Value {
+        Value::new(Form::PartialExpr(e), t, Span::Artificial)
     }
-    pub(crate) fn from_kind_and_type_whnf(v: ValueKind, t: Value) -> Value {
+    /// Make a Value from a ValueKind
+    pub(crate) fn from_kind_and_type(v: ValueKind, t: Value) -> Value {
         Value::new(Form::WHNF(v), t, Span::Artificial)
     }
     pub(crate) fn from_const(c: Const) -> Self {
@@ -188,7 +196,7 @@ impl Value {
     pub(crate) fn kind(&self) -> Ref<ValueKind> {
         self.normalize_whnf();
         Ref::map(self.as_internal(), |vint| match &vint.form {
-            Form::Thunk(..) | Form::Unevaled(..) => unreachable!(),
+            Form::Thunk(..) | Form::PartialExpr(..) => unreachable!(),
             Form::WHNF(k) => k,
         })
     }
@@ -228,7 +236,7 @@ impl Value {
     pub(crate) fn normalize_whnf(&self) {
         let borrow = self.as_internal();
         match borrow.form {
-            Form::Thunk(..) | Form::Unevaled(_) => {
+            Form::Thunk(..) | Form::PartialExpr(_) => {
                 drop(borrow);
                 self.as_internal_mut().normalize_whnf();
             }
@@ -248,10 +256,7 @@ impl Value {
             }
             _ => unreachable!("Internal type error"),
         };
-        Value::from_kind_and_type_whnf(
-            apply_any(self.clone(), v, &body_t),
-            body_t,
-        )
+        Value::from_kind_and_type(apply_any(self.clone(), v, &body_t), body_t)
     }
 
     /// In debug mode, panic if the provided type doesn't match the value's type.
@@ -398,12 +403,13 @@ impl ValueInternal {
 
     fn normalize_whnf(&mut self) {
         use std::mem::replace;
-        let dummy = Form::Unevaled(ValueKind::Const(Const::Type));
+        let dummy = Form::PartialExpr(ExprKind::Const(Const::Type));
         self.form = match replace(&mut self.form, dummy) {
             Form::Thunk(th) => Form::WHNF(th.eval().kind().clone()),
-            Form::Unevaled(kind) => {
+            Form::PartialExpr(e) => {
                 Form::WHNF(match &self.ty {
-                    Some(ty) => normalize_whnf(kind, &ty),
+                    // TODO: env
+                    Some(ty) => normalize_one_layer(e, &ty, &NzEnv::new()),
                     // `value` is `Sort`
                     None => ValueKind::Const(Const::Sort),
                 })
@@ -413,11 +419,11 @@ impl ValueInternal {
         };
     }
     fn normalize_nf(&mut self) {
-        if let Form::Thunk(..) | Form::Unevaled(_) = self.form {
+        if let Form::Thunk(..) | Form::PartialExpr(_) = self.form {
             self.normalize_whnf();
         }
         match &mut self.form {
-            Form::Thunk(..) | Form::Unevaled(_) => unreachable!(),
+            Form::Thunk(..) | Form::PartialExpr(_) => unreachable!(),
             Form::WHNF(k) => k.normalize_mut(),
         }
     }
@@ -451,9 +457,10 @@ impl ValueKind {
             ValueKind::NEOptionalLit(th) => {
                 th.normalize_mut();
             }
-            ValueKind::LamClosure { annot, .. }
-            | ValueKind::PiClosure { annot, .. } => {
+            ValueKind::LamClosure { annot, closure, .. }
+            | ValueKind::PiClosure { annot, closure, .. } => {
                 annot.normalize_mut();
+                closure.normalize_mut();
             }
             ValueKind::AppliedBuiltin(closure) => closure.normalize_mut(),
             ValueKind::NEListLit(elts) => {
@@ -553,6 +560,8 @@ impl Closure {
         }
     }
 
+    // TODO: somehow normalize the body. Might require to pass an env.
+    pub fn normalize_mut(&mut self) {}
     /// Convert this closure to a TyExpr
     pub fn to_tyexpr(&self, venv: VarEnv) -> TyExpr {
         self.apply_var(NzVar::new(venv.size()))
@@ -665,9 +674,9 @@ impl std::fmt::Debug for Value {
                 x.field("thunk", th);
                 x
             }
-            Form::Unevaled(kind) => {
-                let mut x = fmt.debug_struct(&format!("Value@Unevaled"));
-                x.field("kind", kind);
+            Form::PartialExpr(e) => {
+                let mut x = fmt.debug_struct(&format!("Value@PartialExpr"));
+                x.field("expr", e);
                 x
             }
             Form::WHNF(kind) => {
-- 
cgit v1.2.3


From d8de45763037937b5c2dedbe5f7bb95a4e7bc7cd Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 19:56:31 +0000
Subject: Avoid unnecessary allocations of `Value`s

---
 dhall/src/semantics/nze/env.rs       | 16 ++++++++++------
 dhall/src/semantics/nze/normalize.rs | 21 +++++++++------------
 dhall/src/semantics/nze/value.rs     |  6 ++----
 dhall/src/semantics/tck/env.rs       |  2 +-
 dhall/src/semantics/tck/tyexpr.rs    |  5 +++--
 5 files changed, 25 insertions(+), 25 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/nze/env.rs b/dhall/src/semantics/nze/env.rs
index 073886e..0b22a8b 100644
--- a/dhall/src/semantics/nze/env.rs
+++ b/dhall/src/semantics/nze/env.rs
@@ -59,14 +59,18 @@ impl NzEnv {
         env.items.push(NzEnvItem::Replaced(e));
         env
     }
-    pub fn lookup_val(&self, var: &AlphaVar) -> Value {
+    pub fn lookup_val(&self, var: &AlphaVar) -> ValueKind {
         let idx = self.items.len() - 1 - var.idx();
         match &self.items[idx] {
-            NzEnvItem::Kept(ty) => Value::from_kind_and_type(
-                ValueKind::Var(NzVar::new(idx)),
-                ty.clone(),
-            ),
-            NzEnvItem::Replaced(x) => x.clone(),
+            NzEnvItem::Kept(_) => ValueKind::Var(NzVar::new(idx)),
+            NzEnvItem::Replaced(x) => x.kind().clone(),
+        }
+    }
+    pub fn lookup_ty(&self, var: &AlphaVar) -> Value {
+        let idx = self.items.len() - 1 - var.idx();
+        match &self.items[idx] {
+            NzEnvItem::Kept(ty) => ty.clone(),
+            NzEnvItem::Replaced(x) => x.get_type().unwrap(),
         }
     }
 }
diff --git a/dhall/src/semantics/nze/normalize.rs b/dhall/src/semantics/nze/normalize.rs
index 7632d12..e677f78 100644
--- a/dhall/src/semantics/nze/normalize.rs
+++ b/dhall/src/semantics/nze/normalize.rs
@@ -445,14 +445,9 @@ pub(crate) fn normalize_one_layer(
 }
 
 /// Normalize a TyExpr into WHNF
-pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> Value {
-    let ty = match tye.get_type() {
-        Ok(ty) => ty,
-        Err(_) => return Value::from_const(Const::Sort),
-    };
-
-    let kind = match tye.kind() {
-        TyExprKind::Var(var) => return env.lookup_val(var),
+pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> ValueKind {
+    match tye.kind() {
+        TyExprKind::Var(var) => env.lookup_val(var),
         TyExprKind::Expr(ExprKind::Lam(binder, annot, body)) => {
             let annot = annot.eval(env);
             ValueKind::LamClosure {
@@ -472,13 +467,15 @@ pub(crate) fn normalize_tyexpr_whnf(tye: &TyExpr, env: &NzEnv) -> Value {
         }
         TyExprKind::Expr(ExprKind::Let(_, None, val, body)) => {
             let val = val.eval(env);
-            return body.eval(&env.insert_value(val));
+            body.eval(&env.insert_value(val)).kind().clone()
         }
         TyExprKind::Expr(e) => {
+            let ty = match tye.get_type() {
+                Ok(ty) => ty,
+                Err(_) => return ValueKind::Const(Const::Sort),
+            };
             let e = e.map_ref(|tye| tye.eval(env));
             normalize_one_layer(e, &ty, env)
         }
-    };
-
-    Value::from_kind_and_type(kind, ty)
+    }
 }
diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index 108dc9c..ff0ca42 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -405,7 +405,7 @@ impl ValueInternal {
         use std::mem::replace;
         let dummy = Form::PartialExpr(ExprKind::Const(Const::Type));
         self.form = match replace(&mut self.form, dummy) {
-            Form::Thunk(th) => Form::WHNF(th.eval().kind().clone()),
+            Form::Thunk(th) => Form::WHNF(th.eval()),
             Form::PartialExpr(e) => {
                 Form::WHNF(match &self.ty {
                     // TODO: env
@@ -516,9 +516,7 @@ impl Thunk {
             body,
         }
     }
-
-    // TODO: maybe return a ValueKind ?
-    pub fn eval(&self) -> Value {
+    pub fn eval(&self) -> ValueKind {
         normalize_tyexpr_whnf(&self.body, &self.env)
     }
 }
diff --git a/dhall/src/semantics/tck/env.rs b/dhall/src/semantics/tck/env.rs
index d4cc37d..812ca7a 100644
--- a/dhall/src/semantics/tck/env.rs
+++ b/dhall/src/semantics/tck/env.rs
@@ -118,7 +118,7 @@ impl TyEnv {
     }
     pub fn lookup(&self, var: &V) -> Option<(TyExprKind, Type)> {
         let var = self.names.unlabel_var(var)?;
-        let ty = self.items.lookup_val(&var).get_type().unwrap();
+        let ty = self.items.lookup_ty(&var);
         Some((TyExprKind::Var(var), ty))
     }
 }
diff --git a/dhall/src/semantics/tck/tyexpr.rs b/dhall/src/semantics/tck/tyexpr.rs
index 4b88048..1a048f9 100644
--- a/dhall/src/semantics/tck/tyexpr.rs
+++ b/dhall/src/semantics/tck/tyexpr.rs
@@ -1,5 +1,4 @@
 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;
@@ -83,7 +82,9 @@ impl TyExpr {
     }
     /// Eval a closed TyExpr fully and recursively;
     pub fn rec_eval_closed_expr(&self) -> Value {
-        normalize_tyexpr_whnf(self, &NzEnv::new())
+        let mut val = self.eval_closed_expr();
+        val.normalize_mut();
+        val
     }
 }
 
-- 
cgit v1.2.3


From b79a9b81a803794a7a86d953ced24f0d3e2fd212 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 20:23:06 +0000
Subject: Only the Form must be in a RefCell

---
 dhall/src/semantics/nze/value.rs | 128 ++++++++++++++++++++-------------------
 1 file changed, 67 insertions(+), 61 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index ff0ca42..d737a0f 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -1,4 +1,4 @@
-use std::cell::{Ref, RefCell, RefMut};
+use std::cell::{Ref, RefCell};
 use std::collections::HashMap;
 use std::rc::Rc;
 
@@ -21,11 +21,11 @@ use crate::{Normalized, NormalizedExpr, ToExprOptions};
 /// (renaming of bound variables) and beta-equivalence (normalization). It will recursively
 /// normalize as needed.
 #[derive(Clone)]
-pub(crate) struct Value(Rc<RefCell<ValueInternal>>);
+pub(crate) struct Value(Rc<ValueInternal>);
 
 #[derive(Debug)]
 struct ValueInternal {
-    form: Form,
+    form: RefCell<Form>,
     /// This is None if and only if `form` is `Sort` (which doesn't have a type)
     ty: Option<Value>,
     span: Span,
@@ -117,28 +117,23 @@ pub(crate) enum ValueKind {
 
 impl Value {
     fn new(form: Form, ty: Value, span: Span) -> Value {
-        ValueInternal {
-            form,
-            ty: Some(ty),
-            span,
-        }
-        .into_value()
+        ValueInternal::new(form, Some(ty), span).into_value()
     }
     pub(crate) fn const_sort() -> Value {
-        ValueInternal {
-            form: Form::WHNF(ValueKind::Const(Const::Sort)),
-            ty: None,
-            span: Span::Artificial,
-        }
+        ValueInternal::new(
+            Form::WHNF(ValueKind::Const(Const::Sort)),
+            None,
+            Span::Artificial,
+        )
         .into_value()
     }
     /// Construct a Value from a completely unnormalized expression.
     pub(crate) fn new_thunk(env: &NzEnv, tye: TyExpr) -> Value {
-        ValueInternal {
-            form: Form::Thunk(Thunk::new(env, tye.clone())),
-            ty: tye.get_type().ok(),
-            span: tye.span().clone(),
-        }
+        ValueInternal::new(
+            Form::Thunk(Thunk::new(env, tye.clone())),
+            tye.get_type().ok(),
+            tye.span().clone(),
+        )
         .into_value()
     }
     /// Construct a Value from a partially normalized expression that's not in WHNF.
@@ -181,21 +176,18 @@ impl Value {
         }
     }
     pub(crate) fn span(&self) -> Span {
-        self.as_internal().span.clone()
+        self.0.span.clone()
     }
 
-    fn as_internal(&self) -> Ref<ValueInternal> {
-        self.0.borrow()
-    }
-    fn as_internal_mut(&self) -> RefMut<ValueInternal> {
-        self.0.borrow_mut()
+    fn as_form(&self) -> Ref<Form> {
+        self.0.form.borrow()
     }
     /// This is what you want if you want to pattern-match on the value.
     /// WARNING: drop this ref before normalizing the same value or you will run into BorrowMut
     /// panics.
     pub(crate) fn kind(&self) -> Ref<ValueKind> {
         self.normalize_whnf();
-        Ref::map(self.as_internal(), |vint| match &vint.form {
+        Ref::map(self.as_form(), |form| match form {
             Form::Thunk(..) | Form::PartialExpr(..) => unreachable!(),
             Form::WHNF(k) => k,
         })
@@ -219,33 +211,25 @@ impl Value {
     }
 
     /// Mutates the contents. If no one else shares this, this avoids a RefCell lock.
-    fn mutate_internal(&mut self, f: impl FnOnce(&mut ValueInternal)) {
+    fn mutate_form(&mut self, f: impl FnOnce(&mut Form, &Option<Value>)) {
         match Rc::get_mut(&mut self.0) {
             // Mutate directly if sole owner
-            Some(refcell) => f(RefCell::get_mut(refcell)),
+            Some(vint) => f(RefCell::get_mut(&mut vint.form), &vint.ty),
             // Otherwise mutate through the refcell
-            None => f(&mut self.as_internal_mut()),
+            None => f(&mut self.0.form.borrow_mut(), &self.0.ty),
         }
     }
     /// Normalizes contents to normal form; faster than `normalize_nf` if
     /// no one else shares this.
     pub(crate) fn normalize_mut(&mut self) {
-        self.mutate_internal(|vint| vint.normalize_nf())
+        self.mutate_form(|form, ty| form.normalize_nf(ty))
     }
 
     pub(crate) fn normalize_whnf(&self) {
-        let borrow = self.as_internal();
-        match borrow.form {
-            Form::Thunk(..) | Form::PartialExpr(_) => {
-                drop(borrow);
-                self.as_internal_mut().normalize_whnf();
-            }
-            // Already in WHNF
-            Form::WHNF(_) => {}
-        }
+        self.0.normalize_whnf()
     }
     pub(crate) fn normalize_nf(&self) {
-        self.as_internal_mut().normalize_nf();
+        self.0.normalize_nf()
     }
 
     pub(crate) fn app(&self, v: Value) -> Value {
@@ -270,7 +254,7 @@ impl Value {
         // );
     }
     pub(crate) fn get_type(&self) -> Result<Value, TypeError> {
-        Ok(self.as_internal().get_type()?.clone())
+        Ok(self.0.get_type()?.clone())
     }
     /// When we know the value isn't `Sort`, this gets the type directly
     pub(crate) fn get_type_not_sort(&self) -> Value {
@@ -387,9 +371,7 @@ impl Value {
             }),
         };
 
-        let self_ty = self.as_internal().ty.clone();
-        let self_span = self.as_internal().span.clone();
-        TyExpr::new(tye, self_ty, self_span)
+        TyExpr::new(tye, self.0.ty.clone(), self.0.span.clone())
     }
     pub fn to_tyexpr_noenv(&self) -> TyExpr {
         self.to_tyexpr(VarEnv::new())
@@ -397,17 +379,48 @@ impl Value {
 }
 
 impl ValueInternal {
+    fn new(form: Form, ty: Option<Value>, span: Span) -> Self {
+        ValueInternal {
+            form: RefCell::new(form),
+            ty,
+            span,
+        }
+    }
     fn into_value(self) -> Value {
-        Value(Rc::new(RefCell::new(self)))
+        Value(Rc::new(self))
     }
 
-    fn normalize_whnf(&mut self) {
+    fn normalize_whnf(&self) {
+        if !self.form.borrow().is_whnf() {
+            self.form.borrow_mut().normalize_whnf(&self.ty)
+        }
+    }
+    fn normalize_nf(&self) {
+        self.form.borrow_mut().normalize_nf(&self.ty)
+    }
+
+    fn get_type(&self) -> Result<&Value, TypeError> {
+        match &self.ty {
+            Some(t) => Ok(t),
+            None => Err(TypeError::new(TypeMessage::Sort)),
+        }
+    }
+}
+
+impl Form {
+    fn is_whnf(&self) -> bool {
+        match self {
+            Form::Thunk(..) | Form::PartialExpr(..) => false,
+            Form::WHNF(..) => true,
+        }
+    }
+    fn normalize_whnf(&mut self, ty: &Option<Value>) {
         use std::mem::replace;
         let dummy = Form::PartialExpr(ExprKind::Const(Const::Type));
-        self.form = match replace(&mut self.form, dummy) {
+        *self = match replace(self, dummy) {
             Form::Thunk(th) => Form::WHNF(th.eval()),
             Form::PartialExpr(e) => {
-                Form::WHNF(match &self.ty {
+                Form::WHNF(match ty {
                     // TODO: env
                     Some(ty) => normalize_one_layer(e, &ty, &NzEnv::new()),
                     // `value` is `Sort`
@@ -418,22 +431,15 @@ impl ValueInternal {
             form @ Form::WHNF(_) => form,
         };
     }
-    fn normalize_nf(&mut self) {
-        if let Form::Thunk(..) | Form::PartialExpr(_) = self.form {
-            self.normalize_whnf();
+    fn normalize_nf(&mut self, ty: &Option<Value>) {
+        if !self.is_whnf() {
+            self.normalize_whnf(ty);
         }
-        match &mut self.form {
+        match self {
             Form::Thunk(..) | Form::PartialExpr(_) => unreachable!(),
             Form::WHNF(k) => k.normalize_mut(),
         }
     }
-
-    fn get_type(&self) -> Result<&Value, TypeError> {
-        match &self.ty {
-            Some(t) => Ok(t),
-            None => Err(TypeError::new(TypeMessage::Sort)),
-        }
-    }
 }
 
 impl ValueKind {
@@ -665,8 +671,8 @@ impl std::cmp::Eq for Closure {}
 
 impl std::fmt::Debug for Value {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let vint: &ValueInternal = &self.as_internal();
-        let mut x = match &vint.form {
+        let vint: &ValueInternal = &self.0;
+        let mut x = match &*vint.form.borrow() {
             Form::Thunk(th) => {
                 let mut x = fmt.debug_struct(&format!("Value@Thunk"));
                 x.field("thunk", th);
-- 
cgit v1.2.3


From a87b22da10aa20cef939d3c3c7b56710a1f78c2c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 20:36:10 +0000
Subject: Move Form::PartialExpr into Thunk

---
 dhall/src/semantics/nze/value.rs | 82 ++++++++++++++++++++++------------------
 1 file changed, 46 insertions(+), 36 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index d737a0f..87ebfcd 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -35,19 +35,23 @@ struct ValueInternal {
 /// explained in the doc for `ValueKind`.
 #[derive(Debug, Clone)]
 pub(crate) enum Form {
-    /// A totally unnormalized value.
+    /// An unevaluated value.
     Thunk(Thunk),
-    /// A partially normalized value that may need to go through `normalize_one_layer`.
-    PartialExpr(ExprKind<Value, Normalized>),
     /// A value in WHNF.
     WHNF(ValueKind),
 }
 
 /// An unevaluated subexpression
 #[derive(Debug, Clone)]
-pub(crate) struct Thunk {
-    env: NzEnv,
-    body: TyExpr,
+pub(crate) enum Thunk {
+    /// A completely unnormalized expression.
+    Thunk { env: NzEnv, body: TyExpr },
+    /// A partially normalized expression that may need to go through `normalize_one_layer`.
+    PartialExpr {
+        env: NzEnv,
+        expr: ExprKind<Value, Normalized>,
+        ty: Value,
+    },
 }
 
 /// An unevaluated subexpression that takes an argument.
@@ -139,9 +143,15 @@ impl Value {
     /// Construct a Value from a partially normalized expression that's not in WHNF.
     pub(crate) fn from_partial_expr(
         e: ExprKind<Value, Normalized>,
-        t: Value,
+        ty: Value,
     ) -> Value {
-        Value::new(Form::PartialExpr(e), t, Span::Artificial)
+        // TODO: env
+        let env = NzEnv::new();
+        Value::new(
+            Form::Thunk(Thunk::from_partial_expr(env, e, ty.clone())),
+            ty,
+            Span::Artificial,
+        )
     }
     /// Make a Value from a ValueKind
     pub(crate) fn from_kind_and_type(v: ValueKind, t: Value) -> Value {
@@ -188,7 +198,7 @@ impl Value {
     pub(crate) fn kind(&self) -> Ref<ValueKind> {
         self.normalize_whnf();
         Ref::map(self.as_form(), |form| match form {
-            Form::Thunk(..) | Form::PartialExpr(..) => unreachable!(),
+            Form::Thunk(..) => unreachable!(),
             Form::WHNF(k) => k,
         })
     }
@@ -211,18 +221,18 @@ impl Value {
     }
 
     /// Mutates the contents. If no one else shares this, this avoids a RefCell lock.
-    fn mutate_form(&mut self, f: impl FnOnce(&mut Form, &Option<Value>)) {
+    fn mutate_form(&mut self, f: impl FnOnce(&mut Form)) {
         match Rc::get_mut(&mut self.0) {
             // Mutate directly if sole owner
-            Some(vint) => f(RefCell::get_mut(&mut vint.form), &vint.ty),
+            Some(vint) => f(RefCell::get_mut(&mut vint.form)),
             // Otherwise mutate through the refcell
-            None => f(&mut self.0.form.borrow_mut(), &self.0.ty),
+            None => f(&mut self.0.form.borrow_mut()),
         }
     }
     /// Normalizes contents to normal form; faster than `normalize_nf` if
     /// no one else shares this.
     pub(crate) fn normalize_mut(&mut self) {
-        self.mutate_form(|form, ty| form.normalize_nf(ty))
+        self.mutate_form(|form| form.normalize_nf())
     }
 
     pub(crate) fn normalize_whnf(&self) {
@@ -392,11 +402,11 @@ impl ValueInternal {
 
     fn normalize_whnf(&self) {
         if !self.form.borrow().is_whnf() {
-            self.form.borrow_mut().normalize_whnf(&self.ty)
+            self.form.borrow_mut().normalize_whnf()
         }
     }
     fn normalize_nf(&self) {
-        self.form.borrow_mut().normalize_nf(&self.ty)
+        self.form.borrow_mut().normalize_nf()
     }
 
     fn get_type(&self) -> Result<&Value, TypeError> {
@@ -410,33 +420,25 @@ impl ValueInternal {
 impl Form {
     fn is_whnf(&self) -> bool {
         match self {
-            Form::Thunk(..) | Form::PartialExpr(..) => false,
+            Form::Thunk(..) => false,
             Form::WHNF(..) => true,
         }
     }
-    fn normalize_whnf(&mut self, ty: &Option<Value>) {
+    fn normalize_whnf(&mut self) {
         use std::mem::replace;
-        let dummy = Form::PartialExpr(ExprKind::Const(Const::Type));
+        let dummy = Form::WHNF(ValueKind::Const(Const::Type));
         *self = match replace(self, dummy) {
             Form::Thunk(th) => Form::WHNF(th.eval()),
-            Form::PartialExpr(e) => {
-                Form::WHNF(match ty {
-                    // TODO: env
-                    Some(ty) => normalize_one_layer(e, &ty, &NzEnv::new()),
-                    // `value` is `Sort`
-                    None => ValueKind::Const(Const::Sort),
-                })
-            }
             // Already in WHNF
             form @ Form::WHNF(_) => form,
         };
     }
-    fn normalize_nf(&mut self, ty: &Option<Value>) {
+    fn normalize_nf(&mut self) {
         if !self.is_whnf() {
-            self.normalize_whnf(ty);
+            self.normalize_whnf();
         }
         match self {
-            Form::Thunk(..) | Form::PartialExpr(_) => unreachable!(),
+            Form::Thunk(..) => unreachable!(),
             Form::WHNF(k) => k.normalize_mut(),
         }
     }
@@ -517,13 +519,26 @@ impl ValueKind {
 
 impl Thunk {
     pub fn new(env: &NzEnv, body: TyExpr) -> Self {
-        Thunk {
+        Thunk::Thunk {
             env: env.clone(),
             body,
         }
     }
+    pub fn from_partial_expr(
+        env: NzEnv,
+        expr: ExprKind<Value, Normalized>,
+        ty: Value,
+    ) -> Self {
+        Thunk::PartialExpr { env, expr, ty }
+    }
+    // TODO: take by value
     pub fn eval(&self) -> ValueKind {
-        normalize_tyexpr_whnf(&self.body, &self.env)
+        match self {
+            Thunk::Thunk { env, body } => normalize_tyexpr_whnf(body, env),
+            Thunk::PartialExpr { env, expr, ty } => {
+                normalize_one_layer(expr.clone(), ty, env)
+            }
+        }
     }
 }
 
@@ -678,11 +693,6 @@ impl std::fmt::Debug for Value {
                 x.field("thunk", th);
                 x
             }
-            Form::PartialExpr(e) => {
-                let mut x = fmt.debug_struct(&format!("Value@PartialExpr"));
-                x.field("expr", e);
-                x
-            }
             Form::WHNF(kind) => {
                 if let ValueKind::Const(c) = kind {
                     return write!(fmt, "{:?}", c);
-- 
cgit v1.2.3


From 884774dbf13fd0a0fb6936c4259527a30a285ff0 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 21:06:12 +0000
Subject: Replace Form with a pair of RefCells, in preparation for OnceCell

---
 dhall/src/semantics/nze/value.rs | 159 +++++++++++++++++----------------------
 1 file changed, 71 insertions(+), 88 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index 87ebfcd..d25e8b5 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -25,22 +25,15 @@ pub(crate) struct Value(Rc<ValueInternal>);
 
 #[derive(Debug)]
 struct ValueInternal {
-    form: RefCell<Form>,
+    /// Exactly one of `thunk` of `kind` must be set at a given time.
+    /// Once `thunk` is unset and `kind` is set, we never go back.
+    thunk: RefCell<Option<Thunk>>,
+    kind: RefCell<Option<ValueKind>>,
     /// This is None if and only if `form` is `Sort` (which doesn't have a type)
     ty: Option<Value>,
     span: Span,
 }
 
-/// A potentially un-evaluated expression. Once we get to WHNF we won't modify the form again, as
-/// explained in the doc for `ValueKind`.
-#[derive(Debug, Clone)]
-pub(crate) enum Form {
-    /// An unevaluated value.
-    Thunk(Thunk),
-    /// A value in WHNF.
-    WHNF(ValueKind),
-}
-
 /// An unevaluated subexpression
 #[derive(Debug, Clone)]
 pub(crate) enum Thunk {
@@ -120,12 +113,9 @@ pub(crate) enum ValueKind {
 }
 
 impl Value {
-    fn new(form: Form, ty: Value, span: Span) -> Value {
-        ValueInternal::new(form, Some(ty), span).into_value()
-    }
     pub(crate) fn const_sort() -> Value {
-        ValueInternal::new(
-            Form::WHNF(ValueKind::Const(Const::Sort)),
+        ValueInternal::from_whnf(
+            ValueKind::Const(Const::Sort),
             None,
             Span::Artificial,
         )
@@ -133,8 +123,8 @@ impl Value {
     }
     /// Construct a Value from a completely unnormalized expression.
     pub(crate) fn new_thunk(env: &NzEnv, tye: TyExpr) -> Value {
-        ValueInternal::new(
-            Form::Thunk(Thunk::new(env, tye.clone())),
+        ValueInternal::from_thunk(
+            Thunk::new(env, tye.clone()),
             tye.get_type().ok(),
             tye.span().clone(),
         )
@@ -147,15 +137,16 @@ impl Value {
     ) -> Value {
         // TODO: env
         let env = NzEnv::new();
-        Value::new(
-            Form::Thunk(Thunk::from_partial_expr(env, e, ty.clone())),
-            ty,
+        ValueInternal::from_thunk(
+            Thunk::from_partial_expr(env, e, ty.clone()),
+            Some(ty),
             Span::Artificial,
         )
+        .into_value()
     }
     /// Make a Value from a ValueKind
     pub(crate) fn from_kind_and_type(v: ValueKind, t: Value) -> Value {
-        Value::new(Form::WHNF(v), t, Span::Artificial)
+        ValueInternal::from_whnf(v, Some(t), Span::Artificial).into_value()
     }
     pub(crate) fn from_const(c: Const) -> Self {
         let v = ValueKind::Const(c);
@@ -189,18 +180,11 @@ impl Value {
         self.0.span.clone()
     }
 
-    fn as_form(&self) -> Ref<Form> {
-        self.0.form.borrow()
-    }
     /// This is what you want if you want to pattern-match on the value.
     /// WARNING: drop this ref before normalizing the same value or you will run into BorrowMut
     /// panics.
     pub(crate) fn kind(&self) -> Ref<ValueKind> {
-        self.normalize_whnf();
-        Ref::map(self.as_form(), |form| match form {
-            Form::Thunk(..) => unreachable!(),
-            Form::WHNF(k) => k,
-        })
+        self.0.kind()
     }
 
     /// Converts a value back to the corresponding AST expression.
@@ -220,24 +204,16 @@ impl Value {
         self.to_whnf_ignore_type()
     }
 
-    /// Mutates the contents. If no one else shares this, this avoids a RefCell lock.
-    fn mutate_form(&mut self, f: impl FnOnce(&mut Form)) {
+    /// Normalizes contents to normal form; faster than `normalize_nf` if
+    /// no one else shares this.
+    pub(crate) fn normalize_mut(&mut self) {
         match Rc::get_mut(&mut self.0) {
             // Mutate directly if sole owner
-            Some(vint) => f(RefCell::get_mut(&mut vint.form)),
+            Some(vint) => vint.normalize_nf_mut(),
             // Otherwise mutate through the refcell
-            None => f(&mut self.0.form.borrow_mut()),
+            None => self.0.normalize_nf(),
         }
     }
-    /// Normalizes contents to normal form; faster than `normalize_nf` if
-    /// no one else shares this.
-    pub(crate) fn normalize_mut(&mut self) {
-        self.mutate_form(|form| form.normalize_nf())
-    }
-
-    pub(crate) fn normalize_whnf(&self) {
-        self.0.normalize_whnf()
-    }
     pub(crate) fn normalize_nf(&self) {
         self.0.normalize_nf()
     }
@@ -389,9 +365,18 @@ impl Value {
 }
 
 impl ValueInternal {
-    fn new(form: Form, ty: Option<Value>, span: Span) -> Self {
+    fn from_whnf(k: ValueKind, ty: Option<Value>, span: Span) -> Self {
         ValueInternal {
-            form: RefCell::new(form),
+            thunk: RefCell::new(None),
+            kind: RefCell::new(Some(k)),
+            ty,
+            span,
+        }
+    }
+    fn from_thunk(th: Thunk, ty: Option<Value>, span: Span) -> Self {
+        ValueInternal {
+            kind: RefCell::new(None),
+            thunk: RefCell::new(Some(th)),
             ty,
             span,
         }
@@ -400,13 +385,38 @@ impl ValueInternal {
         Value(Rc::new(self))
     }
 
+    fn kind(&self) -> Ref<ValueKind> {
+        self.normalize_whnf();
+        Ref::map(self.kind.borrow(), |kind| kind.as_ref().unwrap())
+    }
     fn normalize_whnf(&self) {
-        if !self.form.borrow().is_whnf() {
-            self.form.borrow_mut().normalize_whnf()
+        if self.kind.borrow().is_none() {
+            let mut thunk_borrow = self.thunk.borrow_mut();
+            let kind = thunk_borrow.as_ref().unwrap().eval();
+            *thunk_borrow = None;
+            *self.kind.borrow_mut() = Some(kind);
         }
     }
     fn normalize_nf(&self) {
-        self.form.borrow_mut().normalize_nf()
+        self.normalize_whnf();
+        self.kind.borrow_mut().as_mut().unwrap().normalize_mut()
+    }
+    // Avoids a RefCell lock
+    fn normalize_whnf_mut(&mut self) {
+        let self_thunk = RefCell::get_mut(&mut self.thunk);
+        if let Some(thunk) = &mut *self_thunk {
+            let self_kind = RefCell::get_mut(&mut self.kind);
+            let mut kind = thunk.eval();
+            kind.normalize_mut();
+            *self_kind = Some(kind);
+            *self_thunk = None;
+        }
+    }
+    // Avoids a RefCell lock
+    fn normalize_nf_mut(&mut self) {
+        self.normalize_whnf_mut();
+        let self_kind = RefCell::get_mut(&mut self.kind);
+        self_kind.as_mut().unwrap().normalize_mut();
     }
 
     fn get_type(&self) -> Result<&Value, TypeError> {
@@ -417,33 +427,6 @@ impl ValueInternal {
     }
 }
 
-impl Form {
-    fn is_whnf(&self) -> bool {
-        match self {
-            Form::Thunk(..) => false,
-            Form::WHNF(..) => true,
-        }
-    }
-    fn normalize_whnf(&mut self) {
-        use std::mem::replace;
-        let dummy = Form::WHNF(ValueKind::Const(Const::Type));
-        *self = match replace(self, dummy) {
-            Form::Thunk(th) => Form::WHNF(th.eval()),
-            // Already in WHNF
-            form @ Form::WHNF(_) => form,
-        };
-    }
-    fn normalize_nf(&mut self) {
-        if !self.is_whnf() {
-            self.normalize_whnf();
-        }
-        match self {
-            Form::Thunk(..) => unreachable!(),
-            Form::WHNF(k) => k.normalize_mut(),
-        }
-    }
-}
-
 impl ValueKind {
     pub(crate) fn into_value_with_type(self, t: Value) -> Value {
         Value::from_kind_and_type(self, t)
@@ -687,21 +670,21 @@ impl std::cmp::Eq for Closure {}
 impl std::fmt::Debug for Value {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let vint: &ValueInternal = &self.0;
-        let mut x = match &*vint.form.borrow() {
-            Form::Thunk(th) => {
-                let mut x = fmt.debug_struct(&format!("Value@Thunk"));
-                x.field("thunk", th);
+        let kind_borrow = vint.kind.borrow();
+        let mut x = if let Some(kind) = kind_borrow.as_ref() {
+            if let ValueKind::Const(c) = kind {
+                return write!(fmt, "{:?}", c);
+            } else {
+                let mut x = fmt.debug_struct(&format!("Value@WHNF"));
+                x.field("kind", kind);
                 x
             }
-            Form::WHNF(kind) => {
-                if let ValueKind::Const(c) = kind {
-                    return write!(fmt, "{:?}", c);
-                } else {
-                    let mut x = fmt.debug_struct(&format!("Value@WHNF"));
-                    x.field("kind", kind);
-                    x
-                }
-            }
+        } else {
+            let thunk_borrow = vint.thunk.borrow();
+            let th = thunk_borrow.as_ref().unwrap();
+            let mut x = fmt.debug_struct(&format!("Value@Thunk"));
+            x.field("thunk", th);
+            x
         };
         if let Some(ty) = vint.ty.as_ref() {
             x.field("type", &ty);
-- 
cgit v1.2.3


From 2700af36adfac4390b9395ac2ed0e534b7eac887 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 21:43:50 +0000
Subject: Use OnceCell to enable returning &ValKind

---
 dhall/Cargo.toml                 |   1 +
 dhall/src/semantics/builtins.rs  |   6 +-
 dhall/src/semantics/nze/value.rs | 121 +++++++++++++++++----------------------
 3 files changed, 57 insertions(+), 71 deletions(-)

(limited to 'dhall')

diff --git a/dhall/Cargo.toml b/dhall/Cargo.toml
index 1479eaa..2fbfb23 100644
--- a/dhall/Cargo.toml
+++ b/dhall/Cargo.toml
@@ -13,6 +13,7 @@ build = "build.rs"
 itertools = "0.8.0"
 hex = "0.3.2"
 lazy_static = "1.4.0"
+ once_cell = "1.3.1"
 percent-encoding = "2.1.0"
 pest = "2.1"
 pest_consume = "1.0"
diff --git a/dhall/src/semantics/builtins.rs b/dhall/src/semantics/builtins.rs
index 85ef294..c20fb77 100644
--- a/dhall/src/semantics/builtins.rs
+++ b/dhall/src/semantics/builtins.rs
@@ -43,9 +43,9 @@ impl BuiltinClosure<Value> {
     }
     /// This doesn't break the invariant because we already checked that the appropriate arguments
     /// did not normalize to something that allows evaluation to proceed.
-    pub fn normalize_mut(&mut self) {
-        for x in self.args.iter_mut() {
-            x.normalize_mut();
+    pub fn normalize(&self) {
+        for x in self.args.iter() {
+            x.normalize();
         }
     }
     pub fn to_tyexprkind(&self, venv: VarEnv) -> TyExprKind {
diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index d25e8b5..945ee6e 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -1,4 +1,5 @@
-use std::cell::{Ref, RefCell};
+use once_cell::unsync::OnceCell;
+use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
 
@@ -28,7 +29,7 @@ struct ValueInternal {
     /// Exactly one of `thunk` of `kind` must be set at a given time.
     /// Once `thunk` is unset and `kind` is set, we never go back.
     thunk: RefCell<Option<Thunk>>,
-    kind: RefCell<Option<ValueKind>>,
+    kind: OnceCell<ValueKind>,
     /// This is None if and only if `form` is `Sort` (which doesn't have a type)
     ty: Option<Value>,
     span: Span,
@@ -183,14 +184,14 @@ impl Value {
     /// This is what you want if you want to pattern-match on the value.
     /// WARNING: drop this ref before normalizing the same value or you will run into BorrowMut
     /// panics.
-    pub(crate) fn kind(&self) -> Ref<ValueKind> {
+    pub(crate) fn kind(&self) -> &ValueKind {
         self.0.kind()
     }
 
     /// Converts a value back to the corresponding AST expression.
     pub(crate) fn to_expr(&self, opts: ToExprOptions) -> NormalizedExpr {
         if opts.normalize {
-            self.normalize_nf();
+            self.normalize();
         }
 
         self.to_tyexpr_noenv().to_expr(opts)
@@ -204,18 +205,18 @@ impl Value {
         self.to_whnf_ignore_type()
     }
 
-    /// Normalizes contents to normal form; faster than `normalize_nf` if
+    /// Normalizes contents to normal form; faster than `normalize` if
     /// no one else shares this.
     pub(crate) fn normalize_mut(&mut self) {
         match Rc::get_mut(&mut self.0) {
             // Mutate directly if sole owner
-            Some(vint) => vint.normalize_nf_mut(),
+            Some(vint) => vint.normalize_mut(),
             // Otherwise mutate through the refcell
-            None => self.0.normalize_nf(),
+            None => self.normalize(),
         }
     }
-    pub(crate) fn normalize_nf(&self) {
-        self.0.normalize_nf()
+    pub(crate) fn normalize(&self) {
+        self.0.normalize()
     }
 
     pub(crate) fn app(&self, v: Value) -> Value {
@@ -366,17 +367,19 @@ impl Value {
 
 impl ValueInternal {
     fn from_whnf(k: ValueKind, ty: Option<Value>, span: Span) -> Self {
+        let kind = OnceCell::new();
+        kind.set(k).unwrap();
         ValueInternal {
             thunk: RefCell::new(None),
-            kind: RefCell::new(Some(k)),
+            kind,
             ty,
             span,
         }
     }
     fn from_thunk(th: Thunk, ty: Option<Value>, span: Span) -> Self {
         ValueInternal {
-            kind: RefCell::new(None),
             thunk: RefCell::new(Some(th)),
+            kind: OnceCell::new(),
             ty,
             span,
         }
@@ -385,38 +388,23 @@ impl ValueInternal {
         Value(Rc::new(self))
     }
 
-    fn kind(&self) -> Ref<ValueKind> {
-        self.normalize_whnf();
-        Ref::map(self.kind.borrow(), |kind| kind.as_ref().unwrap())
-    }
-    fn normalize_whnf(&self) {
-        if self.kind.borrow().is_none() {
-            let mut thunk_borrow = self.thunk.borrow_mut();
-            let kind = thunk_borrow.as_ref().unwrap().eval();
-            *thunk_borrow = None;
-            *self.kind.borrow_mut() = Some(kind);
+    fn kind(&self) -> &ValueKind {
+        if self.kind.get().is_none() {
+            let thunk = self.thunk.borrow_mut().take().unwrap();
+            self.kind.set(thunk.eval()).unwrap();
         }
+        self.kind.get().unwrap()
     }
-    fn normalize_nf(&self) {
-        self.normalize_whnf();
-        self.kind.borrow_mut().as_mut().unwrap().normalize_mut()
+    fn normalize(&self) {
+        self.kind().normalize();
     }
     // Avoids a RefCell lock
-    fn normalize_whnf_mut(&mut self) {
-        let self_thunk = RefCell::get_mut(&mut self.thunk);
-        if let Some(thunk) = &mut *self_thunk {
-            let self_kind = RefCell::get_mut(&mut self.kind);
-            let mut kind = thunk.eval();
-            kind.normalize_mut();
-            *self_kind = Some(kind);
-            *self_thunk = None;
+    fn normalize_mut(&mut self) {
+        if self.kind.get().is_none() {
+            let thunk = RefCell::get_mut(&mut self.thunk).take().unwrap();
+            self.kind.set(thunk.eval()).unwrap();
         }
-    }
-    // Avoids a RefCell lock
-    fn normalize_nf_mut(&mut self) {
-        self.normalize_whnf_mut();
-        let self_kind = RefCell::get_mut(&mut self.kind);
-        self_kind.as_mut().unwrap().normalize_mut();
+        self.normalize();
     }
 
     fn get_type(&self) -> Result<&Value, TypeError> {
@@ -432,7 +420,7 @@ impl ValueKind {
         Value::from_kind_and_type(self, t)
     }
 
-    pub(crate) fn normalize_mut(&mut self) {
+    pub(crate) fn normalize(&self) {
         match self {
             ValueKind::Var(..)
             | ValueKind::Const(_)
@@ -442,52 +430,52 @@ impl ValueKind {
             | ValueKind::DoubleLit(_) => {}
 
             ValueKind::EmptyOptionalLit(tth) | ValueKind::EmptyListLit(tth) => {
-                tth.normalize_mut();
+                tth.normalize();
             }
 
             ValueKind::NEOptionalLit(th) => {
-                th.normalize_mut();
+                th.normalize();
             }
             ValueKind::LamClosure { annot, closure, .. }
             | ValueKind::PiClosure { annot, closure, .. } => {
-                annot.normalize_mut();
-                closure.normalize_mut();
+                annot.normalize();
+                closure.normalize();
             }
-            ValueKind::AppliedBuiltin(closure) => closure.normalize_mut(),
+            ValueKind::AppliedBuiltin(closure) => closure.normalize(),
             ValueKind::NEListLit(elts) => {
-                for x in elts.iter_mut() {
-                    x.normalize_mut();
+                for x in elts.iter() {
+                    x.normalize();
                 }
             }
             ValueKind::RecordLit(kvs) => {
-                for x in kvs.values_mut() {
-                    x.normalize_mut();
+                for x in kvs.values() {
+                    x.normalize();
                 }
             }
             ValueKind::RecordType(kvs) => {
-                for x in kvs.values_mut() {
-                    x.normalize_mut();
+                for x in kvs.values() {
+                    x.normalize();
                 }
             }
             ValueKind::UnionType(kts)
             | ValueKind::UnionConstructor(_, kts, _) => {
-                for x in kts.values_mut().flat_map(|opt| opt) {
-                    x.normalize_mut();
+                for x in kts.values().flat_map(|opt| opt) {
+                    x.normalize();
                 }
             }
             ValueKind::UnionLit(_, v, kts, _, _) => {
-                v.normalize_mut();
-                for x in kts.values_mut().flat_map(|opt| opt) {
-                    x.normalize_mut();
+                v.normalize();
+                for x in kts.values().flat_map(|opt| opt) {
+                    x.normalize();
                 }
             }
-            ValueKind::TextLit(tlit) => tlit.normalize_mut(),
+            ValueKind::TextLit(tlit) => tlit.normalize(),
             ValueKind::Equivalence(x, y) => {
-                x.normalize_mut();
-                y.normalize_mut();
+                x.normalize();
+                y.normalize();
             }
             ValueKind::PartialExpr(e) => {
-                e.map_mut(Value::normalize_mut);
+                e.map_ref(Value::normalize);
             }
         }
     }
@@ -563,7 +551,7 @@ impl Closure {
     }
 
     // TODO: somehow normalize the body. Might require to pass an env.
-    pub fn normalize_mut(&mut self) {}
+    pub fn normalize(&self) {}
     /// Convert this closure to a TyExpr
     pub fn to_tyexpr(&self, venv: VarEnv) -> TyExpr {
         self.apply_var(NzVar::new(venv.size()))
@@ -634,9 +622,9 @@ impl TextLit {
     }
     /// Normalize the contained values. This does not break the invariant because we have already
     /// ensured that no contained values normalize to a TextLit.
-    pub fn normalize_mut(&mut self) {
-        for x in self.0.iter_mut() {
-            x.map_mut(Value::normalize_mut);
+    pub fn normalize(&self) {
+        for x in self.0.iter() {
+            x.map_ref(Value::normalize);
         }
     }
 }
@@ -670,8 +658,7 @@ impl std::cmp::Eq for Closure {}
 impl std::fmt::Debug for Value {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let vint: &ValueInternal = &self.0;
-        let kind_borrow = vint.kind.borrow();
-        let mut x = if let Some(kind) = kind_borrow.as_ref() {
+        let mut x = if let Some(kind) = vint.kind.get() {
             if let ValueKind::Const(c) = kind {
                 return write!(fmt, "{:?}", c);
             } else {
@@ -680,10 +667,8 @@ impl std::fmt::Debug for Value {
                 x
             }
         } else {
-            let thunk_borrow = vint.thunk.borrow();
-            let th = thunk_borrow.as_ref().unwrap();
             let mut x = fmt.debug_struct(&format!("Value@Thunk"));
-            x.field("thunk", th);
+            x.field("thunk", vint.thunk.borrow().as_ref().unwrap());
             x
         };
         if let Some(ty) = vint.ty.as_ref() {
-- 
cgit v1.2.3


From ace2a1f2783f770dc801f74e9118d39c73eb158a Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 22:00:32 +0000
Subject: Get rid of all the manual Ref borrows

---
 dhall/src/semantics/nze/normalize.rs | 170 ++++++++++++-----------------------
 dhall/src/semantics/tck/typecheck.rs |  54 +++++------
 2 files changed, 75 insertions(+), 149 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/nze/normalize.rs b/dhall/src/semantics/nze/normalize.rs
index e677f78..e9d140b 100644
--- a/dhall/src/semantics/nze/normalize.rs
+++ b/dhall/src/semantics/nze/normalize.rs
@@ -11,8 +11,7 @@ use crate::syntax::{
 use crate::Normalized;
 
 pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind {
-    let f_borrow = f.kind();
-    match &*f_borrow {
+    match f.kind() {
         ValueKind::LamClosure { closure, .. } => {
             closure.apply(a).to_whnf_check_type(ty)
         }
@@ -26,10 +25,7 @@ pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind {
             uniont.clone(),
             f.get_type().unwrap(),
         ),
-        _ => {
-            drop(f_borrow);
-            ValueKind::PartialExpr(ExprKind::App(f, a))
-        }
+        _ => ValueKind::PartialExpr(ExprKind::App(f, a)),
     }
 }
 
@@ -47,21 +43,17 @@ pub(crate) fn squash_textlit(
         for contents in elts {
             match contents {
                 Text(s) => crnt_str.push_str(&s),
-                Expr(e) => {
-                    let e_borrow = e.kind();
-                    match &*e_borrow {
-                        ValueKind::TextLit(elts2) => {
-                            inner(elts2.iter().cloned(), crnt_str, ret)
-                        }
-                        _ => {
-                            drop(e_borrow);
-                            if !crnt_str.is_empty() {
-                                ret.push(Text(replace(crnt_str, String::new())))
-                            }
-                            ret.push(Expr(e.clone()))
+                Expr(e) => match e.kind() {
+                    ValueKind::TextLit(elts2) => {
+                        inner(elts2.iter().cloned(), crnt_str, ret)
+                    }
+                    _ => {
+                        if !crnt_str.is_empty() {
+                            ret.push(Text(replace(crnt_str, String::new())))
                         }
+                        ret.push(Expr(e.clone()))
                     }
-                }
+                },
             }
         }
     }
@@ -123,9 +115,7 @@ fn apply_binop<'a>(
     use ValueKind::{
         BoolLit, EmptyListLit, NEListLit, NaturalLit, RecordLit, RecordType,
     };
-    let x_borrow = x.kind();
-    let y_borrow = y.kind();
-    Some(match (o, &*x_borrow, &*y_borrow) {
+    Some(match (o, x.kind(), y.kind()) {
         (BoolAnd, BoolLit(true), _) => Ret::ValueRef(y),
         (BoolAnd, _, BoolLit(true)) => Ret::ValueRef(x),
         (BoolAnd, BoolLit(false), _) => Ret::ValueKind(BoolLit(false)),
@@ -202,8 +192,7 @@ fn apply_binop<'a>(
             Ret::ValueRef(y)
         }
         (RecursiveRecordMerge, RecordLit(kvs1), RecordLit(kvs2)) => {
-            let ty_borrow = ty.kind();
-            let kts = match &*ty_borrow {
+            let kts = match ty.kind() {
                 RecordType(kts) => kts,
                 _ => unreachable!("Internal type error"),
             };
@@ -314,23 +303,15 @@ pub(crate) fn normalize_one_layer(
             }
         }
         ExprKind::BoolIf(ref b, ref e1, ref e2) => {
-            let b_borrow = b.kind();
-            match &*b_borrow {
+            match b.kind() {
                 BoolLit(true) => Ret::ValueRef(e1),
                 BoolLit(false) => Ret::ValueRef(e2),
                 _ => {
-                    let e1_borrow = e1.kind();
-                    let e2_borrow = e2.kind();
-                    match (&*e1_borrow, &*e2_borrow) {
+                    match (e1.kind(), e2.kind()) {
                         // Simplify `if b then True else False`
                         (BoolLit(true), BoolLit(false)) => Ret::ValueRef(b),
                         _ if e1 == e2 => Ret::ValueRef(e1),
-                        _ => {
-                            drop(b_borrow);
-                            drop(e1_borrow);
-                            drop(e2_borrow);
-                            Ret::Expr(expr)
-                        }
+                        _ => Ret::Expr(expr),
                     }
                 }
             }
@@ -343,94 +324,53 @@ pub(crate) fn normalize_one_layer(
         ExprKind::Projection(_, ref ls) if ls.is_empty() => {
             Ret::ValueKind(RecordLit(HashMap::new()))
         }
-        ExprKind::Projection(ref v, ref ls) => {
-            let v_borrow = v.kind();
-            match &*v_borrow {
-                RecordLit(kvs) => Ret::ValueKind(RecordLit(
-                    ls.iter()
-                        .filter_map(|l| {
-                            kvs.get(l).map(|x| (l.clone(), x.clone()))
-                        })
-                        .collect(),
-                )),
-                _ => {
-                    drop(v_borrow);
-                    Ret::Expr(expr)
-                }
-            }
-        }
-        ExprKind::Field(ref v, ref l) => {
-            let v_borrow = v.kind();
-            match &*v_borrow {
-                RecordLit(kvs) => match kvs.get(l) {
-                    Some(r) => Ret::Value(r.clone()),
-                    None => {
-                        drop(v_borrow);
-                        Ret::Expr(expr)
-                    }
-                },
-                UnionType(kts) => Ret::ValueKind(UnionConstructor(
-                    l.clone(),
-                    kts.clone(),
-                    v.get_type().unwrap(),
-                )),
-                _ => {
-                    drop(v_borrow);
-                    Ret::Expr(expr)
-                }
-            }
-        }
+        ExprKind::Projection(ref v, ref ls) => match v.kind() {
+            RecordLit(kvs) => Ret::ValueKind(RecordLit(
+                ls.iter()
+                    .filter_map(|l| kvs.get(l).map(|x| (l.clone(), x.clone())))
+                    .collect(),
+            )),
+            _ => Ret::Expr(expr),
+        },
+        ExprKind::Field(ref v, ref l) => match v.kind() {
+            RecordLit(kvs) => match kvs.get(l) {
+                Some(r) => Ret::Value(r.clone()),
+                None => Ret::Expr(expr),
+            },
+            UnionType(kts) => Ret::ValueKind(UnionConstructor(
+                l.clone(),
+                kts.clone(),
+                v.get_type().unwrap(),
+            )),
+            _ => Ret::Expr(expr),
+        },
         ExprKind::ProjectionByExpr(_, _) => {
             unimplemented!("selection by expression")
         }
         ExprKind::Completion(_, _) => unimplemented!("record completion"),
 
         ExprKind::Merge(ref handlers, ref variant, _) => {
-            let handlers_borrow = handlers.kind();
-            let variant_borrow = variant.kind();
-            match (&*handlers_borrow, &*variant_borrow) {
-                (RecordLit(kvs), UnionConstructor(l, _, _)) => match kvs.get(l)
-                {
-                    Some(h) => Ret::Value(h.clone()),
-                    None => {
-                        drop(handlers_borrow);
-                        drop(variant_borrow);
-                        Ret::Expr(expr)
-                    }
-                },
-                (RecordLit(kvs), UnionLit(l, v, _, _, _)) => match kvs.get(l) {
-                    Some(h) => Ret::Value(h.app(v.clone())),
-                    None => {
-                        drop(handlers_borrow);
-                        drop(variant_borrow);
-                        Ret::Expr(expr)
-                    }
-                },
-                (RecordLit(kvs), EmptyOptionalLit(_)) => {
-                    match kvs.get(&"None".into()) {
+            match handlers.kind() {
+                RecordLit(kvs) => match variant.kind() {
+                    UnionConstructor(l, _, _) => match kvs.get(l) {
                         Some(h) => Ret::Value(h.clone()),
-                        None => {
-                            drop(handlers_borrow);
-                            drop(variant_borrow);
-                            Ret::Expr(expr)
-                        }
-                    }
-                }
-                (RecordLit(kvs), NEOptionalLit(v)) => {
-                    match kvs.get(&"Some".into()) {
+                        None => Ret::Expr(expr),
+                    },
+                    UnionLit(l, v, _, _, _) => match kvs.get(l) {
                         Some(h) => Ret::Value(h.app(v.clone())),
-                        None => {
-                            drop(handlers_borrow);
-                            drop(variant_borrow);
-                            Ret::Expr(expr)
-                        }
-                    }
-                }
-                _ => {
-                    drop(handlers_borrow);
-                    drop(variant_borrow);
-                    Ret::Expr(expr)
-                }
+                        None => Ret::Expr(expr),
+                    },
+                    EmptyOptionalLit(_) => match kvs.get(&"None".into()) {
+                        Some(h) => Ret::Value(h.clone()),
+                        None => Ret::Expr(expr),
+                    },
+                    NEOptionalLit(v) => match kvs.get(&"Some".into()) {
+                        Some(h) => Ret::Value(h.app(v.clone())),
+                        None => Ret::Expr(expr),
+                    },
+                    _ => Ret::Expr(expr),
+                },
+                _ => Ret::Expr(expr),
             }
         }
         ExprKind::ToMap(_, _) => unimplemented!("toMap"),
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index 212e6e7..e3f57c2 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -197,8 +197,7 @@ fn type_one_layer(
                 // TODO: branch here only when scrut.get_type() is a Const
                 _ => {
                     let scrut_nf = scrut.eval(env.as_nzenv());
-                    let scrut_nf_borrow = scrut_nf.kind();
-                    match &*scrut_nf_borrow {
+                    match scrut_nf.kind() {
                         ValueKind::UnionType(kts) => match kts.get(x) {
                             // Constructor has type T -> < x: T, ... >
                             Some(Some(ty)) => Value::from_kind_and_type(
@@ -215,7 +214,7 @@ fn type_one_layer(
                                     scrut.get_type()?,
                                 )?,
                             ),
-                            Some(None) => scrut_nf.clone(),
+                            Some(None) => scrut_nf,
                             None => return mkerr("MissingUnionField"),
                         },
                         _ => return mkerr("NotARecord"),
@@ -252,9 +251,7 @@ fn type_one_layer(
             t
         }
         ExprKind::App(f, arg) => {
-            let tf = f.get_type()?;
-            let tf_borrow = tf.kind();
-            match &*tf_borrow {
+            match f.get_type()?.kind() {
                 ValueKind::PiClosure { annot, closure, .. } => {
                     if arg.get_type()? != *annot {
                         // return mkerr(format!("function annot mismatch"));
@@ -295,15 +292,12 @@ fn type_one_layer(
             let y_type = y.get_type()?;
 
             // Extract the LHS record type
-            let x_type_borrow = x_type.kind();
-            let kts_x = match &*x_type_borrow {
+            let kts_x = match x_type.kind() {
                 ValueKind::RecordType(kts) => kts,
                 _ => return mkerr("MustCombineRecord"),
             };
-
             // Extract the RHS record type
-            let y_type_borrow = y_type.kind();
-            let kts_y = match &*y_type_borrow {
+            let kts_y = match y_type.kind() {
                 ValueKind::RecordType(kts) => kts,
                 _ => return mkerr("MustCombineRecord"),
             };
@@ -334,13 +328,11 @@ fn type_one_layer(
         ExprKind::BinOp(BinOp::RecursiveRecordTypeMerge, x, y) => {
             let x_val = x.eval(env.as_nzenv());
             let y_val = y.eval(env.as_nzenv());
-            let x_val_borrow = x_val.kind();
-            let y_val_borrow = y_val.kind();
-            let kts_x = match &*x_val_borrow {
+            let kts_x = match x_val.kind() {
                 ValueKind::RecordType(kts) => kts,
                 _ => return mkerr("RecordTypeMergeRequiresRecordType"),
             };
-            let kts_y = match &*y_val_borrow {
+            let kts_y = match y_val.kind() {
                 ValueKind::RecordType(kts) => kts,
                 _ => return mkerr("RecordTypeMergeRequiresRecordType"),
             };
@@ -416,15 +408,13 @@ fn type_one_layer(
         }
         ExprKind::Merge(record, union, type_annot) => {
             let record_type = record.get_type()?;
-            let record_borrow = record_type.kind();
-            let handlers = match &*record_borrow {
+            let handlers = match record_type.kind() {
                 ValueKind::RecordType(kts) => kts,
                 _ => return mkerr("Merge1ArgMustBeRecord"),
             };
 
             let union_type = union.get_type()?;
-            let union_borrow = union_type.kind();
-            let variants = match &*union_borrow {
+            let variants = match union_type.kind() {
                 ValueKind::UnionType(kts) => Cow::Borrowed(kts),
                 ValueKind::AppliedBuiltin(BuiltinClosure {
                     b: Builtin::Optional,
@@ -444,21 +434,18 @@ fn type_one_layer(
             for (x, handler_type) in handlers {
                 let handler_return_type = match variants.get(x) {
                     // Union alternative with type
-                    Some(Some(variant_type)) => {
-                        let handler_type_borrow = handler_type.kind();
-                        match &*handler_type_borrow {
-                            ValueKind::PiClosure { closure, annot, .. } => {
-                                if variant_type != annot {
-                                    return mkerr("MergeHandlerTypeMismatch");
-                                }
-
-                                closure.remove_binder().or_else(|()| {
-                                    mkerr("MergeReturnTypeIsDependent")
-                                })?
+                    Some(Some(variant_type)) => match handler_type.kind() {
+                        ValueKind::PiClosure { closure, annot, .. } => {
+                            if variant_type != annot {
+                                return mkerr("MergeHandlerTypeMismatch");
                             }
-                            _ => return mkerr("NotAFunction"),
+
+                            closure.remove_binder().or_else(|()| {
+                                mkerr("MergeReturnTypeIsDependent")
+                            })?
                         }
-                    }
+                        _ => return mkerr("NotAFunction"),
+                    },
                     // Union alternative without type
                     Some(None) => handler_type.clone(),
                     None => return mkerr("MergeHandlerMissingVariant"),
@@ -495,8 +482,7 @@ fn type_one_layer(
         ExprKind::ToMap(_, _) => unimplemented!("toMap"),
         ExprKind::Projection(record, labels) => {
             let record_type = record.get_type()?;
-            let record_type_borrow = record_type.kind();
-            let kts = match &*record_type_borrow {
+            let kts = match record_type.kind() {
                 ValueKind::RecordType(kts) => kts,
                 _ => return mkerr("ProjectionMustBeRecord"),
             };
-- 
cgit v1.2.3


From 4e2bb03bcf6355d49216c6886bf03e5aeaad16cc Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 22:01:54 +0000
Subject: Eval Thunk by move

---
 dhall/src/semantics/nze/value.rs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index 945ee6e..724e3e8 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -502,12 +502,11 @@ impl Thunk {
     ) -> Self {
         Thunk::PartialExpr { env, expr, ty }
     }
-    // TODO: take by value
-    pub fn eval(&self) -> ValueKind {
+    pub fn eval(self) -> ValueKind {
         match self {
-            Thunk::Thunk { env, body } => normalize_tyexpr_whnf(body, env),
+            Thunk::Thunk { env, body } => normalize_tyexpr_whnf(&body, &env),
             Thunk::PartialExpr { env, expr, ty } => {
-                normalize_one_layer(expr.clone(), ty, env)
+                normalize_one_layer(expr, &ty, &env)
             }
         }
     }
-- 
cgit v1.2.3


From 70af1a47bce9e6c8282d6e53cf82aeda9aab10de Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 22:08:57 +0000
Subject: Tweak ConstantClosure

---
 dhall/src/semantics/nze/value.rs     | 20 +++++++-------------
 dhall/src/semantics/tck/typecheck.rs | 26 ++++++++++++++------------
 2 files changed, 21 insertions(+), 25 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index 724e3e8..67ab90a 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -58,7 +58,7 @@ pub(crate) enum Closure {
         body: TyExpr,
     },
     /// Closure that ignores the argument passed
-    ConstantClosure { env: NzEnv, body: TyExpr },
+    ConstantClosure { body: Value },
 }
 
 /// A text literal with interpolations.
@@ -521,11 +521,8 @@ impl Closure {
         }
     }
     /// New closure that ignores its argument
-    pub fn new_constant(env: &NzEnv, body: TyExpr) -> Self {
-        Closure::ConstantClosure {
-            env: env.clone(),
-            body,
-        }
+    pub fn new_constant(body: Value) -> Self {
+        Closure::ConstantClosure { body }
     }
 
     pub fn apply(&self, val: Value) -> Value {
@@ -533,7 +530,7 @@ impl Closure {
             Closure::Closure { env, body, .. } => {
                 body.eval(&env.insert_value(val))
             }
-            Closure::ConstantClosure { env, body, .. } => body.eval(env),
+            Closure::ConstantClosure { body, .. } => body.clone(),
         }
     }
     fn apply_var(&self, var: NzVar) -> Value {
@@ -545,7 +542,7 @@ impl Closure {
                 );
                 self.apply(val)
             }
-            Closure::ConstantClosure { env, body, .. } => body.eval(env),
+            Closure::ConstantClosure { body, .. } => body.clone(),
         }
     }
 
@@ -559,17 +556,14 @@ impl Closure {
     /// If the closure variable is free in the closure, return Err. Otherwise, return the value
     /// with that free variable remove.
     pub fn remove_binder(&self) -> Result<Value, ()> {
-        let v = NzVar::fresh();
         match self {
             Closure::Closure { .. } => {
+                let v = NzVar::fresh();
                 // TODO: handle case where variable is used in closure
                 // TODO: return information about where the variable is used
                 Ok(self.apply_var(v))
             }
-            Closure::ConstantClosure { .. } => {
-                // Ok: the variable is indeed ignored
-                Ok(self.apply_var(v))
-            }
+            Closure::ConstantClosure { body, .. } => Ok(body.clone()),
         }
     }
 }
diff --git a/dhall/src/semantics/tck/typecheck.rs b/dhall/src/semantics/tck/typecheck.rs
index e3f57c2..20076cd 100644
--- a/dhall/src/semantics/tck/typecheck.rs
+++ b/dhall/src/semantics/tck/typecheck.rs
@@ -200,20 +200,22 @@ fn type_one_layer(
                     match scrut_nf.kind() {
                         ValueKind::UnionType(kts) => match kts.get(x) {
                             // Constructor has type T -> < x: T, ... >
-                            Some(Some(ty)) => Value::from_kind_and_type(
-                                ValueKind::PiClosure {
-                                    binder: Binder::new(x.clone()),
-                                    annot: ty.clone(),
-                                    closure: Closure::new_constant(
-                                        env.as_nzenv(),
-                                        scrut.clone(),
-                                    ),
-                                },
-                                type_of_function(
+                            Some(Some(ty)) => {
+                                let pi_ty = type_of_function(
                                     ty.get_type()?,
                                     scrut.get_type()?,
-                                )?,
-                            ),
+                                )?;
+                                Value::from_kind_and_type(
+                                    ValueKind::PiClosure {
+                                        binder: Binder::new(x.clone()),
+                                        annot: ty.clone(),
+                                        closure: Closure::new_constant(
+                                            scrut_nf,
+                                        ),
+                                    },
+                                    pi_ty,
+                                )
+                            }
                             Some(None) => scrut_nf,
                             None => return mkerr("MissingUnionField"),
                         },
-- 
cgit v1.2.3


From 4312ad935d881f269fa7e9cc3d880fa763db957d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 30 Jan 2020 22:10:40 +0000
Subject: Use Rc equality to shortcut Value equality

---
 dhall/src/semantics/nze/value.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'dhall')

diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index 67ab90a..de40d53 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -623,10 +623,9 @@ impl TextLit {
 }
 
 /// Compare two values for equality modulo alpha/beta-equivalence.
-// TODO: use Rc comparison to shortcut on identical pointers
 impl std::cmp::PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {
-        *self.kind() == *other.kind()
+        Rc::ptr_eq(&self.0, &other.0) || self.kind() == other.kind()
     }
 }
 impl std::cmp::Eq for Value {}
-- 
cgit v1.2.3


From aa93f18c8ef9ad13c6bb4ddef90b419b3ed546f4 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 31 Jan 2020 19:46:16 +0000
Subject: Factor out custom Lazy struct

---
 dhall/src/semantics/nze/lazy.rs  | 64 ++++++++++++++++++++++++++++++++++++++++
 dhall/src/semantics/nze/mod.rs   |  1 +
 dhall/src/semantics/nze/value.rs | 53 +++++++++++----------------------
 3 files changed, 83 insertions(+), 35 deletions(-)
 create mode 100644 dhall/src/semantics/nze/lazy.rs

(limited to 'dhall')

diff --git a/dhall/src/semantics/nze/lazy.rs b/dhall/src/semantics/nze/lazy.rs
new file mode 100644
index 0000000..d361313
--- /dev/null
+++ b/dhall/src/semantics/nze/lazy.rs
@@ -0,0 +1,64 @@
+use once_cell::unsync::OnceCell;
+use std::cell::Cell;
+use std::fmt::Debug;
+use std::ops::Deref;
+
+pub trait Eval<Tgt> {
+    fn eval(self) -> Tgt;
+}
+
+/// A value which is initialized from a `Src` on the first access.
+pub struct Lazy<Src, Tgt> {
+    /// Exactly one of `src` of `tgt` must be set at a given time.
+    /// Once `src` is unset and `tgt` is set, we never go back.
+    src: Cell<Option<Src>>,
+    tgt: OnceCell<Tgt>,
+}
+
+impl<Src, Tgt> Lazy<Src, Tgt>
+where
+    Src: Eval<Tgt>,
+{
+    /// Creates a new lazy value with the given initializing value.
+    pub fn new(src: Src) -> Self {
+        Lazy {
+            src: Cell::new(Some(src)),
+            tgt: OnceCell::new(),
+        }
+    }
+    /// Creates a new lazy value with the given already-initialized value.
+    pub fn new_completed(tgt: Tgt) -> Self {
+        let lazy = Lazy {
+            src: Cell::new(None),
+            tgt: OnceCell::new(),
+        };
+        let _ = lazy.tgt.set(tgt);
+        lazy
+    }
+}
+
+impl<Src, Tgt> Deref for Lazy<Src, Tgt>
+where
+    Src: Eval<Tgt>,
+{
+    type Target = Tgt;
+    fn deref(&self) -> &Self::Target {
+        self.tgt.get_or_init(|| {
+            let src = self.src.take().unwrap();
+            src.eval()
+        })
+    }
+}
+
+impl<Src, Tgt> Debug for Lazy<Src, Tgt>
+where
+    Tgt: Debug,
+{
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(tgt) = self.tgt.get() {
+            fmt.debug_tuple("Lazy@Init").field(tgt).finish()
+        } else {
+            fmt.debug_tuple("Lazy@Uninit").finish()
+        }
+    }
+}
diff --git a/dhall/src/semantics/nze/mod.rs b/dhall/src/semantics/nze/mod.rs
index 3d9c5eb..2c8d907 100644
--- a/dhall/src/semantics/nze/mod.rs
+++ b/dhall/src/semantics/nze/mod.rs
@@ -1,4 +1,5 @@
 pub mod env;
+pub mod lazy;
 pub mod normalize;
 pub mod value;
 pub mod var;
diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs
index de40d53..ae06942 100644
--- a/dhall/src/semantics/nze/value.rs
+++ b/dhall/src/semantics/nze/value.rs
@@ -1,9 +1,8 @@
-use once_cell::unsync::OnceCell;
-use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
 
 use crate::error::{TypeError, TypeMessage};
+use crate::semantics::nze::lazy;
 use crate::semantics::Binder;
 use crate::semantics::{
     apply_any, normalize_one_layer, normalize_tyexpr_whnf, squash_textlit,
@@ -26,10 +25,7 @@ pub(crate) struct Value(Rc<ValueInternal>);
 
 #[derive(Debug)]
 struct ValueInternal {
-    /// Exactly one of `thunk` of `kind` must be set at a given time.
-    /// Once `thunk` is unset and `kind` is set, we never go back.
-    thunk: RefCell<Option<Thunk>>,
-    kind: OnceCell<ValueKind>,
+    kind: lazy::Lazy<Thunk, ValueKind>,
     /// This is None if and only if `form` is `Sort` (which doesn't have a type)
     ty: Option<Value>,
     span: Span,
@@ -367,19 +363,15 @@ impl Value {
 
 impl ValueInternal {
     fn from_whnf(k: ValueKind, ty: Option<Value>, span: Span) -> Self {
-        let kind = OnceCell::new();
-        kind.set(k).unwrap();
         ValueInternal {
-            thunk: RefCell::new(None),
-            kind,
+            kind: lazy::Lazy::new_completed(k),
             ty,
             span,
         }
     }
     fn from_thunk(th: Thunk, ty: Option<Value>, span: Span) -> Self {
         ValueInternal {
-            thunk: RefCell::new(Some(th)),
-            kind: OnceCell::new(),
+            kind: lazy::Lazy::new(th),
             ty,
             span,
         }
@@ -389,21 +381,13 @@ impl ValueInternal {
     }
 
     fn kind(&self) -> &ValueKind {
-        if self.kind.get().is_none() {
-            let thunk = self.thunk.borrow_mut().take().unwrap();
-            self.kind.set(thunk.eval()).unwrap();
-        }
-        self.kind.get().unwrap()
+        &self.kind
     }
     fn normalize(&self) {
         self.kind().normalize();
     }
-    // Avoids a RefCell lock
+    // TODO: deprecated
     fn normalize_mut(&mut self) {
-        if self.kind.get().is_none() {
-            let thunk = RefCell::get_mut(&mut self.thunk).take().unwrap();
-            self.kind.set(thunk.eval()).unwrap();
-        }
         self.normalize();
     }
 
@@ -622,6 +606,12 @@ impl TextLit {
     }
 }
 
+impl lazy::Eval<ValueKind> for Thunk {
+    fn eval(self) -> ValueKind {
+        self.eval()
+    }
+}
+
 /// Compare two values for equality modulo alpha/beta-equivalence.
 impl std::cmp::PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {
@@ -650,19 +640,12 @@ impl std::cmp::Eq for Closure {}
 impl std::fmt::Debug for Value {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let vint: &ValueInternal = &self.0;
-        let mut x = if let Some(kind) = vint.kind.get() {
-            if let ValueKind::Const(c) = kind {
-                return write!(fmt, "{:?}", c);
-            } else {
-                let mut x = fmt.debug_struct(&format!("Value@WHNF"));
-                x.field("kind", kind);
-                x
-            }
-        } else {
-            let mut x = fmt.debug_struct(&format!("Value@Thunk"));
-            x.field("thunk", vint.thunk.borrow().as_ref().unwrap());
-            x
-        };
+        let kind = vint.kind();
+        if let ValueKind::Const(c) = kind {
+            return write!(fmt, "{:?}", c);
+        }
+        let mut x = fmt.debug_struct(&format!("Value@WHNF"));
+        x.field("kind", kind);
         if let Some(ty) = vint.ty.as_ref() {
             x.field("type", &ty);
         } else {
-- 
cgit v1.2.3