Rename ValueF to ValueKind

9 files changed, 523 insertions, 513 deletions

diff --git a/dhall/src/semantics/core/context.rs b/dhall/src/semantics/core/context.rs
index d150e56..8861378 100644
--- a/dhall/src/semantics/core/context.rs
+++ b/dhall/src/semantics/core/context.rs
@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 use crate::semantics::core::value::Value;
-use crate::semantics::core::valuef::ValueF;
+use crate::semantics::core::value_kind::ValueKind;
 use crate::semantics::core::var::{AlphaVar, Shift, Subst};
 use crate::semantics::error::TypeError;
 use crate::syntax::{Label, V};
@@ -39,7 +39,7 @@ impl TypecheckContext {
                     let i = i.under_multiple_binders(&shift_map);
                     return Some(match i {
                         CtxItem::Kept(newvar, t) => {
-                            Value::from_valuef_and_type(ValueF::Var(newvar), t)
+                            Value::from_kind_and_type(ValueKind::Var(newvar), t)
                         }
                         CtxItem::Replaced(v) => v,
                     });
diff --git a/dhall/src/semantics/core/mod.rs b/dhall/src/semantics/core/mod.rs
index 08213f7..bf3d390 100644
--- a/dhall/src/semantics/core/mod.rs
+++ b/dhall/src/semantics/core/mod.rs
@@ -1,4 +1,4 @@
 pub mod context;
 pub mod value;
-pub mod valuef;
+pub mod value_kind;
 pub mod var;
diff --git a/dhall/src/semantics/core/value.rs b/dhall/src/semantics/core/value.rs
index 6e6739f..7403742 100644
--- a/dhall/src/semantics/core/value.rs
+++ b/dhall/src/semantics/core/value.rs
@@ -2,7 +2,7 @@ use std::cell::{Ref, RefCell, RefMut};
 use std::rc::Rc;
 
 use crate::semantics::core::context::TypecheckContext;
-use crate::semantics::core::valuef::ValueF;
+use crate::semantics::core::value_kind::ValueKind;
 use crate::semantics::core::var::{AlphaVar, Shift, Subst};
 use crate::semantics::error::{TypeError, TypeMessage};
 use crate::semantics::phase::normalize::{apply_any, normalize_whnf};
@@ -15,12 +15,12 @@ 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 ValueF is the first
+    /// 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 ValueF are at least in WHNF, and recursively so, then the
-    /// ValueF is in NF. This is because WHNF ensures that we have the first constructor of the NF; so
+    /// When all the Values in a ValueKind are at least 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,
 }
@@ -32,7 +32,7 @@ use Form::{Unevaled, NF, WHNF};
 #[derive(Debug)]
 struct ValueInternal {
     form: Form,
-    value: ValueF,
+    kind: ValueKind,
     /// This is None if and only if `value` is `Sort` (which doesn't have a type)
     ty: Option<Value>,
     span: Span,
@@ -57,8 +57,8 @@ impl ValueInternal {
     fn into_value(self) -> Value {
         Value(Rc::new(RefCell::new(self)))
     }
-    fn as_valuef(&self) -> &ValueF {
-        &self.value
+    fn as_kind(&self) -> &ValueKind {
+        &self.kind
     }
 
     fn normalize_whnf(&mut self) {
@@ -67,21 +67,21 @@ impl ValueInternal {
             // Dummy value in case the other closure panics
             || ValueInternal {
                 form: Unevaled,
-                value: ValueF::Const(Const::Type),
+                kind: ValueKind::Const(Const::Type),
                 ty: None,
                 span: Span::Artificial,
             },
             |vint| match (&vint.form, &vint.ty) {
                 (Unevaled, Some(ty)) => ValueInternal {
                     form: WHNF,
-                    value: normalize_whnf(vint.value, &ty),
+                    kind: normalize_whnf(vint.kind, &ty),
                     ty: vint.ty,
                     span: vint.span,
                 },
                 // `value` is `Sort`
                 (Unevaled, None) => ValueInternal {
                     form: NF,
-                    value: ValueF::Const(Const::Sort),
+                    kind: ValueKind::Const(Const::Sort),
                     ty: None,
                     span: vint.span,
                 },
@@ -97,7 +97,7 @@ impl ValueInternal {
                 self.normalize_nf();
             }
             WHNF => {
-                self.value.normalize_mut();
+                self.kind.normalize_mut();
                 self.form = NF;
             }
             // Already in NF
@@ -116,10 +116,10 @@ impl ValueInternal {
 }
 
 impl Value {
-    fn new(value: ValueF, form: Form, ty: Value, span: Span) -> Value {
+    fn new(kind: ValueKind, form: Form, ty: Value, span: Span) -> Value {
         ValueInternal {
             form,
-            value,
+            kind,
             ty: Some(ty),
             span,
         }
@@ -128,23 +128,23 @@ impl Value {
     pub(crate) fn const_sort() -> Value {
         ValueInternal {
             form: NF,
-            value: ValueF::Const(Const::Sort),
+            kind: ValueKind::Const(Const::Sort),
             ty: None,
             span: Span::Artificial,
         }
         .into_value()
     }
-    pub(crate) fn from_valuef_and_type(v: ValueF, 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_valuef_and_type_and_span(
-        v: ValueF,
+    pub(crate) fn from_kind_and_type_and_span(
+        v: ValueKind,
         t: Value,
         span: Span,
     ) -> Value {
         Value::new(v, Unevaled, t, span)
     }
-    pub(crate) fn from_valuef_and_type_whnf(v: ValueF, 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 {
@@ -160,7 +160,7 @@ impl Value {
 
     pub(crate) fn as_const(&self) -> Option<Const> {
         match &*self.as_whnf() {
-            ValueF::Const(c) => Some(*c),
+            ValueKind::Const(c) => Some(*c),
             _ => None,
         }
     }
@@ -174,30 +174,30 @@ impl Value {
     fn as_internal_mut(&self) -> RefMut<ValueInternal> {
         self.0.borrow_mut()
     }
-    /// WARNING: The returned ValueF may be entirely unnormalized, in aprticular it may just be an
+    /// WARNING: The returned ValueKind may be entirely unnormalized, in aprticular it may just be an
     /// unevaled PartialExpr. You probably want to use `as_whnf`.
-    fn as_valuef(&self) -> Ref<ValueF> {
-        Ref::map(self.as_internal(), ValueInternal::as_valuef)
+    fn as_kind(&self) -> Ref<ValueKind> {
+        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<ValueF> {
+    pub(crate) fn as_whnf(&self) -> Ref<ValueKind> {
         self.normalize_whnf();
-        self.as_valuef()
+        self.as_kind()
     }
 
     pub(crate) fn to_expr(&self, opts: ToExprOptions) -> NormalizedExpr {
         if opts.normalize {
             self.normalize_whnf();
         }
-        self.as_valuef().to_expr(opts)
+        self.as_kind().to_expr(opts)
     }
-    pub(crate) fn to_whnf_ignore_type(&self) -> ValueF {
+    pub(crate) fn to_whnf_ignore_type(&self) -> ValueKind {
         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) -> ValueF {
+    pub(crate) fn to_whnf_check_type(&self, ty: &Value) -> ValueKind {
         self.check_type(ty);
         self.to_whnf_ignore_type()
     }
@@ -234,13 +234,13 @@ impl Value {
 
     pub(crate) fn app(&self, v: Value) -> Value {
         let body_t = match &*self.get_type_not_sort().as_whnf() {
-            ValueF::Pi(x, t, e) => {
+            ValueKind::Pi(x, t, e) => {
                 v.check_type(t);
                 e.subst_shift(&x.into(), &v)
             }
             _ => unreachable!("Internal type error"),
         };
-        Value::from_valuef_and_type_whnf(
+        Value::from_kind_and_type_whnf(
             apply_any(self.clone(), v, &body_t),
             body_t,
         )
@@ -275,7 +275,7 @@ impl Shift for ValueInternal {
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
         Some(ValueInternal {
             form: self.form,
-            value: self.value.shift(delta, var)?,
+            kind: self.kind.shift(delta, var)?,
             ty: self.ty.shift(delta, var)?,
             span: self.span.clone(),
         })
@@ -284,10 +284,10 @@ impl Shift for ValueInternal {
 
 impl Subst<Value> for Value {
     fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
-        match &*self.as_valuef() {
+        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.
-            ValueF::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));
                 }
@@ -303,7 +303,7 @@ impl Subst<Value> for ValueInternal {
         ValueInternal {
             // The resulting value may not stay in wnhf after substitution
             form: Unevaled,
-            value: self.value.subst_shift(var, val),
+            kind: self.kind.subst_shift(var, val),
             ty: self.ty.subst_shift(var, val),
             span: self.span.clone(),
         }
@@ -321,11 +321,11 @@ impl std::cmp::Eq for Value {}
 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 ValueF::Const(c) = &vint.value {
+        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.value);
+            x.field("value", &vint.kind);
             if let Some(ty) = vint.ty.as_ref() {
                 x.field("type", &ty);
             } else {
diff --git a/dhall/src/semantics/core/value_kind.rs b/dhall/src/semantics/core/value_kind.rs
new file mode 100644
index 0000000..36ba068
--- /dev/null
+++ b/dhall/src/semantics/core/value_kind.rs
@@ -0,0 +1,333 @@
+use std::collections::HashMap;
+
+use crate::semantics::core::value::{ToExprOptions, Value};
+use crate::semantics::core::var::{AlphaLabel, AlphaVar, Shift, Subst};
+use crate::semantics::phase::typecheck::rc;
+use crate::semantics::phase::{Normalized, NormalizedExpr};
+use crate::syntax;
+use crate::syntax::{
+    Builtin, Const, ExprF, Integer, InterpolatedTextContents, Label,
+    NaiveDouble, Natural,
+};
+
+/// A semantic value. Subexpressions are Values, which are partially evaluated expressions that are
+/// normalized on-demand.
+/// If you compare for equality two `ValueKind`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(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum ValueKind {
+    /// Closures
+    Lam(AlphaLabel, Value, Value),
+    Pi(AlphaLabel, Value, Value),
+    // Invariant: in whnf, the evaluation must not be able to progress further.
+    AppliedBuiltin(Builtin, Vec<Value>),
+
+    Var(AlphaVar),
+    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>>),
+    UnionConstructor(Label, HashMap<Label, Option<Value>>),
+    UnionLit(Label, Value, HashMap<Label, Option<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(ExprF<Value, Normalized>),
+}
+
+impl ValueKind {
+    pub(crate) fn into_value_with_type(self, t: Value) -> Value {
+        Value::from_kind_and_type(self, t)
+    }
+
+    pub(crate) fn to_expr(&self, opts: ToExprOptions) -> NormalizedExpr {
+        match self {
+            ValueKind::Lam(x, t, e) => rc(ExprF::Lam(
+                x.to_label_maybe_alpha(opts.alpha),
+                t.to_expr(opts),
+                e.to_expr(opts),
+            )),
+            ValueKind::AppliedBuiltin(b, args) => args
+                .iter()
+                .map(|v| v.to_expr(opts))
+                .fold(rc(ExprF::Builtin(*b)), |acc, v| rc(ExprF::App(acc, v))),
+            ValueKind::Pi(x, t, e) => rc(ExprF::Pi(
+                x.to_label_maybe_alpha(opts.alpha),
+                t.to_expr(opts),
+                e.to_expr(opts),
+            )),
+            ValueKind::Var(v) => rc(ExprF::Var(v.to_var(opts.alpha))),
+            ValueKind::Const(c) => rc(ExprF::Const(*c)),
+            ValueKind::BoolLit(b) => rc(ExprF::BoolLit(*b)),
+            ValueKind::NaturalLit(n) => rc(ExprF::NaturalLit(*n)),
+            ValueKind::IntegerLit(n) => rc(ExprF::IntegerLit(*n)),
+            ValueKind::DoubleLit(n) => rc(ExprF::DoubleLit(*n)),
+            ValueKind::EmptyOptionalLit(n) => rc(ExprF::App(
+                rc(ExprF::Builtin(Builtin::OptionalNone)),
+                n.to_expr(opts),
+            )),
+            ValueKind::NEOptionalLit(n) => rc(ExprF::SomeLit(n.to_expr(opts))),
+            ValueKind::EmptyListLit(n) => rc(ExprF::EmptyListLit(rc(
+                ExprF::App(rc(ExprF::Builtin(Builtin::List)), n.to_expr(opts)),
+            ))),
+            ValueKind::NEListLit(elts) => rc(ExprF::NEListLit(
+                elts.iter().map(|n| n.to_expr(opts)).collect(),
+            )),
+            ValueKind::RecordLit(kvs) => rc(ExprF::RecordLit(
+                kvs.iter()
+                    .map(|(k, v)| (k.clone(), v.to_expr(opts)))
+                    .collect(),
+            )),
+            ValueKind::RecordType(kts) => rc(ExprF::RecordType(
+                kts.iter()
+                    .map(|(k, v)| (k.clone(), v.to_expr(opts)))
+                    .collect(),
+            )),
+            ValueKind::UnionType(kts) => rc(ExprF::UnionType(
+                kts.iter()
+                    .map(|(k, v)| {
+                        (k.clone(), v.as_ref().map(|v| v.to_expr(opts)))
+                    })
+                    .collect(),
+            )),
+            ValueKind::UnionConstructor(l, kts) => rc(ExprF::Field(
+                ValueKind::UnionType(kts.clone()).to_expr(opts),
+                l.clone(),
+            )),
+            ValueKind::UnionLit(l, v, kts) => rc(ExprF::App(
+                ValueKind::UnionConstructor(l.clone(), kts.clone())
+                    .to_expr(opts),
+                v.to_expr(opts),
+            )),
+            ValueKind::TextLit(elts) => rc(ExprF::TextLit(
+                elts.iter()
+                    .map(|contents| contents.map_ref(|e| e.to_expr(opts)))
+                    .collect(),
+            )),
+            ValueKind::Equivalence(x, y) => rc(ExprF::BinOp(
+                syntax::BinOp::Equivalence,
+                x.to_expr(opts),
+                y.to_expr(opts),
+            )),
+            ValueKind::PartialExpr(e) => rc(e.map_ref(|v| v.to_expr(opts))),
+        }
+    }
+
+    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::Lam(_, t, e) => {
+                t.normalize_mut();
+                e.normalize_mut();
+            }
+            ValueKind::Pi(_, t, e) => {
+                t.normalize_mut();
+                e.normalize_mut();
+            }
+            ValueKind::AppliedBuiltin(_, args) => {
+                for x in args.iter_mut() {
+                    x.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);
+            }
+        }
+    }
+
+    pub(crate) fn from_builtin(b: Builtin) -> ValueKind {
+        ValueKind::AppliedBuiltin(b, vec![])
+    }
+}
+
+impl Shift for ValueKind {
+    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)?)
+            }
+        })
+    }
+}
+
+impl Subst<Value> for ValueKind {
+    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),
+            ),
+        }
+    }
+}
diff --git a/dhall/src/semantics/core/valuef.rs b/dhall/src/semantics/core/valuef.rs
deleted file mode 100644
index 73c715a..0000000
--- a/dhall/src/semantics/core/valuef.rs
+++ /dev/null
@@ -1,323 +0,0 @@
-use std::collections::HashMap;
-
-use crate::semantics::core::value::{ToExprOptions, Value};
-use crate::semantics::core::var::{AlphaLabel, AlphaVar, Shift, Subst};
-use crate::semantics::phase::typecheck::rc;
-use crate::semantics::phase::{Normalized, NormalizedExpr};
-use crate::syntax;
-use crate::syntax::{
-    Builtin, Const, ExprF, Integer, InterpolatedTextContents, Label,
-    NaiveDouble, Natural,
-};
-
-/// A semantic value. Subexpressions are Values, which are partially evaluated expressions that are
-/// normalized on-demand.
-/// If you compare for equality two `ValueF`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(Debug, Clone, PartialEq, Eq)]
-pub(crate) enum ValueF {
-    /// Closures
-    Lam(AlphaLabel, Value, Value),
-    Pi(AlphaLabel, Value, Value),
-    // Invariant: in whnf, the evaluation must not be able to progress further.
-    AppliedBuiltin(Builtin, Vec<Value>),
-
-    Var(AlphaVar),
-    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>>),
-    UnionConstructor(Label, HashMap<Label, Option<Value>>),
-    UnionLit(Label, Value, HashMap<Label, Option<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(ExprF<Value, Normalized>),
-}
-
-impl ValueF {
-    pub(crate) fn into_value_with_type(self, t: Value) -> Value {
-        Value::from_valuef_and_type(self, t)
-    }
-
-    pub(crate) fn to_expr(&self, opts: ToExprOptions) -> NormalizedExpr {
-        match self {
-            ValueF::Lam(x, t, e) => rc(ExprF::Lam(
-                x.to_label_maybe_alpha(opts.alpha),
-                t.to_expr(opts),
-                e.to_expr(opts),
-            )),
-            ValueF::AppliedBuiltin(b, args) => args
-                .iter()
-                .map(|v| v.to_expr(opts))
-                .fold(rc(ExprF::Builtin(*b)), |acc, v| rc(ExprF::App(acc, v))),
-            ValueF::Pi(x, t, e) => rc(ExprF::Pi(
-                x.to_label_maybe_alpha(opts.alpha),
-                t.to_expr(opts),
-                e.to_expr(opts),
-            )),
-            ValueF::Var(v) => rc(ExprF::Var(v.to_var(opts.alpha))),
-            ValueF::Const(c) => rc(ExprF::Const(*c)),
-            ValueF::BoolLit(b) => rc(ExprF::BoolLit(*b)),
-            ValueF::NaturalLit(n) => rc(ExprF::NaturalLit(*n)),
-            ValueF::IntegerLit(n) => rc(ExprF::IntegerLit(*n)),
-            ValueF::DoubleLit(n) => rc(ExprF::DoubleLit(*n)),
-            ValueF::EmptyOptionalLit(n) => rc(ExprF::App(
-                rc(ExprF::Builtin(Builtin::OptionalNone)),
-                n.to_expr(opts),
-            )),
-            ValueF::NEOptionalLit(n) => rc(ExprF::SomeLit(n.to_expr(opts))),
-            ValueF::EmptyListLit(n) => rc(ExprF::EmptyListLit(rc(ExprF::App(
-                rc(ExprF::Builtin(Builtin::List)),
-                n.to_expr(opts),
-            )))),
-            ValueF::NEListLit(elts) => rc(ExprF::NEListLit(
-                elts.iter().map(|n| n.to_expr(opts)).collect(),
-            )),
-            ValueF::RecordLit(kvs) => rc(ExprF::RecordLit(
-                kvs.iter()
-                    .map(|(k, v)| (k.clone(), v.to_expr(opts)))
-                    .collect(),
-            )),
-            ValueF::RecordType(kts) => rc(ExprF::RecordType(
-                kts.iter()
-                    .map(|(k, v)| (k.clone(), v.to_expr(opts)))
-                    .collect(),
-            )),
-            ValueF::UnionType(kts) => rc(ExprF::UnionType(
-                kts.iter()
-                    .map(|(k, v)| {
-                        (k.clone(), v.as_ref().map(|v| v.to_expr(opts)))
-                    })
-                    .collect(),
-            )),
-            ValueF::UnionConstructor(l, kts) => rc(ExprF::Field(
-                ValueF::UnionType(kts.clone()).to_expr(opts),
-                l.clone(),
-            )),
-            ValueF::UnionLit(l, v, kts) => rc(ExprF::App(
-                ValueF::UnionConstructor(l.clone(), kts.clone()).to_expr(opts),
-                v.to_expr(opts),
-            )),
-            ValueF::TextLit(elts) => rc(ExprF::TextLit(
-                elts.iter()
-                    .map(|contents| contents.map_ref(|e| e.to_expr(opts)))
-                    .collect(),
-            )),
-            ValueF::Equivalence(x, y) => rc(ExprF::BinOp(
-                syntax::BinOp::Equivalence,
-                x.to_expr(opts),
-                y.to_expr(opts),
-            )),
-            ValueF::PartialExpr(e) => rc(e.map_ref(|v| v.to_expr(opts))),
-        }
-    }
-
-    pub(crate) fn normalize_mut(&mut self) {
-        match self {
-            ValueF::Var(_)
-            | ValueF::Const(_)
-            | ValueF::BoolLit(_)
-            | ValueF::NaturalLit(_)
-            | ValueF::IntegerLit(_)
-            | ValueF::DoubleLit(_) => {}
-
-            ValueF::EmptyOptionalLit(tth) | ValueF::EmptyListLit(tth) => {
-                tth.normalize_mut();
-            }
-
-            ValueF::NEOptionalLit(th) => {
-                th.normalize_mut();
-            }
-            ValueF::Lam(_, t, e) => {
-                t.normalize_mut();
-                e.normalize_mut();
-            }
-            ValueF::Pi(_, t, e) => {
-                t.normalize_mut();
-                e.normalize_mut();
-            }
-            ValueF::AppliedBuiltin(_, args) => {
-                for x in args.iter_mut() {
-                    x.normalize_mut();
-                }
-            }
-            ValueF::NEListLit(elts) => {
-                for x in elts.iter_mut() {
-                    x.normalize_mut();
-                }
-            }
-            ValueF::RecordLit(kvs) => {
-                for x in kvs.values_mut() {
-                    x.normalize_mut();
-                }
-            }
-            ValueF::RecordType(kvs) => {
-                for x in kvs.values_mut() {
-                    x.normalize_mut();
-                }
-            }
-            ValueF::UnionType(kts) | ValueF::UnionConstructor(_, kts) => {
-                for x in kts.values_mut().flat_map(|opt| opt) {
-                    x.normalize_mut();
-                }
-            }
-            ValueF::UnionLit(_, v, kts) => {
-                v.normalize_mut();
-                for x in kts.values_mut().flat_map(|opt| opt) {
-                    x.normalize_mut();
-                }
-            }
-            ValueF::TextLit(elts) => {
-                for x in elts.iter_mut() {
-                    x.map_mut(Value::normalize_mut);
-                }
-            }
-            ValueF::Equivalence(x, y) => {
-                x.normalize_mut();
-                y.normalize_mut();
-            }
-            ValueF::PartialExpr(e) => {
-                e.map_mut(Value::normalize_mut);
-            }
-        }
-    }
-
-    pub(crate) fn from_builtin(b: Builtin) -> ValueF {
-        ValueF::AppliedBuiltin(b, vec![])
-    }
-}
-
-impl Shift for ValueF {
-    fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        Some(match self {
-            ValueF::Lam(x, t, e) => ValueF::Lam(
-                x.clone(),
-                t.shift(delta, var)?,
-                e.shift(delta, &var.under_binder(x))?,
-            ),
-            ValueF::AppliedBuiltin(b, args) => {
-                ValueF::AppliedBuiltin(*b, args.shift(delta, var)?)
-            }
-            ValueF::Pi(x, t, e) => ValueF::Pi(
-                x.clone(),
-                t.shift(delta, var)?,
-                e.shift(delta, &var.under_binder(x))?,
-            ),
-            ValueF::Var(v) => ValueF::Var(v.shift(delta, var)?),
-            ValueF::Const(c) => ValueF::Const(*c),
-            ValueF::BoolLit(b) => ValueF::BoolLit(*b),
-            ValueF::NaturalLit(n) => ValueF::NaturalLit(*n),
-            ValueF::IntegerLit(n) => ValueF::IntegerLit(*n),
-            ValueF::DoubleLit(n) => ValueF::DoubleLit(*n),
-            ValueF::EmptyOptionalLit(tth) => {
-                ValueF::EmptyOptionalLit(tth.shift(delta, var)?)
-            }
-            ValueF::NEOptionalLit(th) => {
-                ValueF::NEOptionalLit(th.shift(delta, var)?)
-            }
-            ValueF::EmptyListLit(tth) => {
-                ValueF::EmptyListLit(tth.shift(delta, var)?)
-            }
-            ValueF::NEListLit(elts) => {
-                ValueF::NEListLit(elts.shift(delta, var)?)
-            }
-            ValueF::RecordLit(kvs) => ValueF::RecordLit(kvs.shift(delta, var)?),
-            ValueF::RecordType(kvs) => {
-                ValueF::RecordType(kvs.shift(delta, var)?)
-            }
-            ValueF::UnionType(kts) => ValueF::UnionType(kts.shift(delta, var)?),
-            ValueF::UnionConstructor(x, kts) => {
-                ValueF::UnionConstructor(x.clone(), kts.shift(delta, var)?)
-            }
-            ValueF::UnionLit(x, v, kts) => ValueF::UnionLit(
-                x.clone(),
-                v.shift(delta, var)?,
-                kts.shift(delta, var)?,
-            ),
-            ValueF::TextLit(elts) => ValueF::TextLit(elts.shift(delta, var)?),
-            ValueF::Equivalence(x, y) => {
-                ValueF::Equivalence(x.shift(delta, var)?, y.shift(delta, var)?)
-            }
-            ValueF::PartialExpr(e) => ValueF::PartialExpr(e.shift(delta, var)?),
-        })
-    }
-}
-
-impl Subst<Value> for ValueF {
-    fn subst_shift(&self, var: &AlphaVar, val: &Value) -> Self {
-        match self {
-            ValueF::AppliedBuiltin(b, args) => {
-                ValueF::AppliedBuiltin(*b, args.subst_shift(var, val))
-            }
-            ValueF::PartialExpr(e) => {
-                ValueF::PartialExpr(e.subst_shift(var, val))
-            }
-            ValueF::TextLit(elts) => {
-                ValueF::TextLit(elts.subst_shift(var, val))
-            }
-            ValueF::Lam(x, t, e) => ValueF::Lam(
-                x.clone(),
-                t.subst_shift(var, val),
-                e.subst_shift(&var.under_binder(x), &val.under_binder(x)),
-            ),
-            ValueF::Pi(x, t, e) => ValueF::Pi(
-                x.clone(),
-                t.subst_shift(var, val),
-                e.subst_shift(&var.under_binder(x), &val.under_binder(x)),
-            ),
-            ValueF::Var(v) if v == var => val.to_whnf_ignore_type(),
-            ValueF::Var(v) => ValueF::Var(v.shift(-1, var).unwrap()),
-            ValueF::Const(c) => ValueF::Const(*c),
-            ValueF::BoolLit(b) => ValueF::BoolLit(*b),
-            ValueF::NaturalLit(n) => ValueF::NaturalLit(*n),
-            ValueF::IntegerLit(n) => ValueF::IntegerLit(*n),
-            ValueF::DoubleLit(n) => ValueF::DoubleLit(*n),
-            ValueF::EmptyOptionalLit(tth) => {
-                ValueF::EmptyOptionalLit(tth.subst_shift(var, val))
-            }
-            ValueF::NEOptionalLit(th) => {
-                ValueF::NEOptionalLit(th.subst_shift(var, val))
-            }
-            ValueF::EmptyListLit(tth) => {
-                ValueF::EmptyListLit(tth.subst_shift(var, val))
-            }
-            ValueF::NEListLit(elts) => {
-                ValueF::NEListLit(elts.subst_shift(var, val))
-            }
-            ValueF::RecordLit(kvs) => {
-                ValueF::RecordLit(kvs.subst_shift(var, val))
-            }
-            ValueF::RecordType(kvs) => {
-                ValueF::RecordType(kvs.subst_shift(var, val))
-            }
-            ValueF::UnionType(kts) => {
-                ValueF::UnionType(kts.subst_shift(var, val))
-            }
-            ValueF::UnionConstructor(x, kts) => {
-                ValueF::UnionConstructor(x.clone(), kts.subst_shift(var, val))
-            }
-            ValueF::UnionLit(x, v, kts) => ValueF::UnionLit(
-                x.clone(),
-                v.subst_shift(var, val),
-                kts.subst_shift(var, val),
-            ),
-            ValueF::Equivalence(x, y) => ValueF::Equivalence(
-                x.subst_shift(var, val),
-                y.subst_shift(var, val),
-            ),
-        }
-    }
-}
diff --git a/dhall/src/semantics/core/var.rs b/dhall/src/semantics/core/var.rs
index 184a372..77473f6 100644
--- a/dhall/src/semantics/core/var.rs
+++ b/dhall/src/semantics/core/var.rs
@@ -12,7 +12,7 @@ pub struct AlphaVar {
 }
 
 // Exactly like a Label, but equality returns always true.
-// This is so that ValueF equality is exactly alpha-equivalence.
+// This is so that ValueKind equality is exactly alpha-equivalence.
 #[derive(Clone, Eq)]
 pub struct AlphaLabel(Label);
 
diff --git a/dhall/src/semantics/phase/mod.rs b/dhall/src/semantics/phase/mod.rs
index 752c257..f27088c 100644
--- a/dhall/src/semantics/phase/mod.rs
+++ b/dhall/src/semantics/phase/mod.rs
@@ -2,7 +2,7 @@ use std::fmt::Display;
 use std::path::Path;
 
 use crate::semantics::core::value::{ToExprOptions, Value};
-use crate::semantics::core::valuef::ValueF;
+use crate::semantics::core::value_kind::ValueKind;
 use crate::semantics::core::var::{AlphaVar, Shift, Subst};
 use crate::semantics::error::{EncodeError, Error, ImportError, TypeError};
 use crate::syntax::binary;
@@ -91,8 +91,8 @@ impl Typed {
     pub(crate) fn from_const(c: Const) -> Self {
         Typed(Value::from_const(c))
     }
-    pub(crate) fn from_valuef_and_type(v: ValueF, t: Typed) -> Self {
-        Typed(Value::from_valuef_and_type(v, t.into_value()))
+    pub(crate) fn from_kind_and_type(v: ValueKind, t: Typed) -> Self {
+        Typed(Value::from_kind_and_type(v, t.into_value()))
     }
     pub(crate) fn from_value(th: Value) -> Self {
         Typed(th)
@@ -148,8 +148,8 @@ impl Typed {
     pub fn make_record_type(
         kts: impl Iterator<Item = (String, Typed)>,
     ) -> Self {
-        Typed::from_valuef_and_type(
-            ValueF::RecordType(
+        Typed::from_kind_and_type(
+            ValueKind::RecordType(
                 kts.map(|(k, t)| (k.into(), t.into_value())).collect(),
             ),
             Typed::const_type(),
@@ -158,8 +158,8 @@ impl Typed {
     pub fn make_union_type(
         kts: impl Iterator<Item = (String, Option<Typed>)>,
     ) -> Self {
-        Typed::from_valuef_and_type(
-            ValueF::UnionType(
+        Typed::from_kind_and_type(
+            ValueKind::UnionType(
                 kts.map(|(k, t)| (k.into(), t.map(|t| t.into_value())))
                     .collect(),
             ),
diff --git a/dhall/src/semantics/phase/normalize.rs b/dhall/src/semantics/phase/normalize.rs
index 81c3ce1..157d1f3 100644
--- a/dhall/src/semantics/phase/normalize.rs
+++ b/dhall/src/semantics/phase/normalize.rs
@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use crate::semantics::core::value::Value;
-use crate::semantics::core::valuef::ValueF;
+use crate::semantics::core::value_kind::ValueKind;
 use crate::semantics::core::var::{AlphaLabel, AlphaVar, Shift, Subst};
 use crate::semantics::phase::Normalized;
 use crate::syntax;
@@ -19,7 +19,7 @@ macro_rules! make_closure {
             Label::from(stringify!($var)).into(),
             $n
         );
-        ValueF::Var(var)
+        ValueKind::Var(var)
             .into_value_with_type(make_closure!($($ty)*))
     }};
     // Warning: assumes that $ty, as a dhall value, has type `Type`
@@ -28,9 +28,9 @@ macro_rules! make_closure {
         let ty = make_closure!($($ty)*);
         let body = make_closure!($($body)*);
         let body_ty = body.get_type_not_sort();
-        let lam_ty = ValueF::Pi(var.clone(), ty.clone(), body_ty)
+        let lam_ty = ValueKind::Pi(var.clone(), ty.clone(), body_ty)
             .into_value_with_type(Value::from_const(Type));
-        ValueF::Lam(var, ty, body).into_value_with_type(lam_ty)
+        ValueKind::Lam(var, ty, body).into_value_with_type(lam_ty)
     }};
     (Natural) => {
         Value::from_builtin(Builtin::Natural)
@@ -43,14 +43,14 @@ macro_rules! make_closure {
         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);
-        ValueF::NEOptionalLit(v).into_value_with_type(opt_v_type)
+        ValueKind::NEOptionalLit(v).into_value_with_type(opt_v_type)
     }};
     (1 + $($rest:tt)*) => {
-        ValueF::PartialExpr(ExprF::BinOp(
+        ValueKind::PartialExpr(ExprF::BinOp(
             syntax::BinOp::NaturalPlus,
             make_closure!($($rest)*),
-            Value::from_valuef_and_type(
-                ValueF::NaturalLit(1),
+            Value::from_kind_and_type(
+                ValueKind::NaturalLit(1),
                 make_closure!(Natural)
             ),
         )).into_value_with_type(
@@ -61,9 +61,9 @@ macro_rules! make_closure {
         let head = make_closure!($($head)*);
         let tail = make_closure!($($tail)*);
         let list_type = tail.get_type_not_sort();
-        ValueF::PartialExpr(ExprF::BinOp(
+        ValueKind::PartialExpr(ExprF::BinOp(
             syntax::BinOp::ListAppend,
-            ValueF::NEListLit(vec![head])
+            ValueKind::NEListLit(vec![head])
                 .into_value_with_type(list_type.clone()),
             tail,
         )).into_value_with_type(list_type)
@@ -75,13 +75,13 @@ pub(crate) fn apply_builtin(
     b: Builtin,
     args: Vec<Value>,
     ty: &Value,
-) -> ValueF {
+) -> ValueKind {
     use syntax::Builtin::*;
-    use ValueF::*;
+    use ValueKind::*;
 
     // Small helper enum
     enum Ret<'a> {
-        ValueF(ValueF),
+        ValueKind(ValueKind),
         Value(Value),
         // For applications that can return a function, it's important to keep the remaining
         // arguments to apply them to the resulting function.
@@ -90,38 +90,38 @@ pub(crate) fn apply_builtin(
     }
 
     let ret = match (b, args.as_slice()) {
-        (OptionalNone, [t]) => Ret::ValueF(EmptyOptionalLit(t.clone())),
+        (OptionalNone, [t]) => Ret::ValueKind(EmptyOptionalLit(t.clone())),
         (NaturalIsZero, [n]) => match &*n.as_whnf() {
-            NaturalLit(n) => Ret::ValueF(BoolLit(*n == 0)),
+            NaturalLit(n) => Ret::ValueKind(BoolLit(*n == 0)),
             _ => Ret::DoneAsIs,
         },
         (NaturalEven, [n]) => match &*n.as_whnf() {
-            NaturalLit(n) => Ret::ValueF(BoolLit(*n % 2 == 0)),
+            NaturalLit(n) => Ret::ValueKind(BoolLit(*n % 2 == 0)),
             _ => Ret::DoneAsIs,
         },
         (NaturalOdd, [n]) => match &*n.as_whnf() {
-            NaturalLit(n) => Ret::ValueF(BoolLit(*n % 2 != 0)),
+            NaturalLit(n) => Ret::ValueKind(BoolLit(*n % 2 != 0)),
             _ => Ret::DoneAsIs,
         },
         (NaturalToInteger, [n]) => match &*n.as_whnf() {
-            NaturalLit(n) => Ret::ValueF(IntegerLit(*n as isize)),
+            NaturalLit(n) => Ret::ValueKind(IntegerLit(*n as isize)),
             _ => Ret::DoneAsIs,
         },
-        (NaturalShow, [n]) => match &*n.as_whnf() {
-            NaturalLit(n) => {
-                Ret::ValueF(TextLit(vec![InterpolatedTextContents::Text(
-                    n.to_string(),
-                )]))
+        (NaturalShow, [n]) => {
+            match &*n.as_whnf() {
+                NaturalLit(n) => Ret::ValueKind(TextLit(vec![
+                    InterpolatedTextContents::Text(n.to_string()),
+                ])),
+                _ => Ret::DoneAsIs,
             }
-            _ => Ret::DoneAsIs,
-        },
+        }
         (NaturalSubtract, [a, b]) => match (&*a.as_whnf(), &*b.as_whnf()) {
             (NaturalLit(a), NaturalLit(b)) => {
-                Ret::ValueF(NaturalLit(if b > a { b - a } else { 0 }))
+                Ret::ValueKind(NaturalLit(if b > a { b - a } else { 0 }))
             }
             (NaturalLit(0), _) => Ret::Value(b.clone()),
-            (_, NaturalLit(0)) => Ret::ValueF(NaturalLit(0)),
-            _ if a == b => Ret::ValueF(NaturalLit(0)),
+            (_, NaturalLit(0)) => Ret::ValueKind(NaturalLit(0)),
+            _ if a == b => Ret::ValueKind(NaturalLit(0)),
             _ => Ret::DoneAsIs,
         },
         (IntegerShow, [n]) => match &*n.as_whnf() {
@@ -131,24 +131,24 @@ pub(crate) fn apply_builtin(
                 } else {
                     format!("+{}", n)
                 };
-                Ret::ValueF(TextLit(vec![InterpolatedTextContents::Text(s)]))
+                Ret::ValueKind(TextLit(vec![InterpolatedTextContents::Text(s)]))
             }
             _ => Ret::DoneAsIs,
         },
         (IntegerToDouble, [n]) => match &*n.as_whnf() {
             IntegerLit(n) => {
-                Ret::ValueF(DoubleLit(NaiveDouble::from(*n as f64)))
+                Ret::ValueKind(DoubleLit(NaiveDouble::from(*n as f64)))
             }
             _ => Ret::DoneAsIs,
         },
-        (DoubleShow, [n]) => match &*n.as_whnf() {
-            DoubleLit(n) => {
-                Ret::ValueF(TextLit(vec![InterpolatedTextContents::Text(
-                    n.to_string(),
-                )]))
+        (DoubleShow, [n]) => {
+            match &*n.as_whnf() {
+                DoubleLit(n) => Ret::ValueKind(TextLit(vec![
+                    InterpolatedTextContents::Text(n.to_string()),
+                ])),
+                _ => Ret::DoneAsIs,
             }
-            _ => Ret::DoneAsIs,
-        },
+        }
         (TextShow, [v]) => match &*v.as_whnf() {
             TextLit(elts) => {
                 match elts.as_slice() {
@@ -158,7 +158,7 @@ pub(crate) fn apply_builtin(
                         let txt: InterpolatedText<Normalized> =
                             std::iter::empty().collect();
                         let s = txt.to_string();
-                        Ret::ValueF(TextLit(vec![
+                        Ret::ValueKind(TextLit(vec![
                             InterpolatedTextContents::Text(s),
                         ]))
                     }
@@ -172,7 +172,7 @@ pub(crate) fn apply_builtin(
                             ))
                             .collect();
                         let s = txt.to_string();
-                        Ret::ValueF(TextLit(vec![
+                        Ret::ValueKind(TextLit(vec![
                             InterpolatedTextContents::Text(s),
                         ]))
                     }
@@ -182,28 +182,28 @@ pub(crate) fn apply_builtin(
             _ => Ret::DoneAsIs,
         },
         (ListLength, [_, l]) => match &*l.as_whnf() {
-            EmptyListLit(_) => Ret::ValueF(NaturalLit(0)),
-            NEListLit(xs) => Ret::ValueF(NaturalLit(xs.len())),
+            EmptyListLit(_) => Ret::ValueKind(NaturalLit(0)),
+            NEListLit(xs) => Ret::ValueKind(NaturalLit(xs.len())),
             _ => Ret::DoneAsIs,
         },
         (ListHead, [_, l]) => match &*l.as_whnf() {
-            EmptyListLit(n) => Ret::ValueF(EmptyOptionalLit(n.clone())),
+            EmptyListLit(n) => Ret::ValueKind(EmptyOptionalLit(n.clone())),
             NEListLit(xs) => {
-                Ret::ValueF(NEOptionalLit(xs.iter().next().unwrap().clone()))
+                Ret::ValueKind(NEOptionalLit(xs.iter().next().unwrap().clone()))
             }
             _ => Ret::DoneAsIs,
         },
         (ListLast, [_, l]) => match &*l.as_whnf() {
-            EmptyListLit(n) => Ret::ValueF(EmptyOptionalLit(n.clone())),
-            NEListLit(xs) => Ret::ValueF(NEOptionalLit(
+            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::ValueF(EmptyListLit(n.clone())),
+            EmptyListLit(n) => Ret::ValueKind(EmptyListLit(n.clone())),
             NEListLit(xs) => {
-                Ret::ValueF(NEListLit(xs.iter().rev().cloned().collect()))
+                Ret::ValueKind(NEListLit(xs.iter().rev().cloned().collect()))
             }
             _ => Ret::DoneAsIs,
         },
@@ -222,7 +222,7 @@ pub(crate) fn apply_builtin(
                     let mut kts = HashMap::new();
                     kts.insert("index".into(), Value::from_builtin(Natural));
                     kts.insert("value".into(), t.clone());
-                    let t = Value::from_valuef_and_type(
+                    let t = Value::from_kind_and_type(
                         RecordType(kts),
                         Value::from_const(Type),
                     );
@@ -237,7 +237,7 @@ pub(crate) fn apply_builtin(
                                     let mut kvs = HashMap::new();
                                     kvs.insert(
                                         "index".into(),
-                                        Value::from_valuef_and_type(
+                                        Value::from_kind_and_type(
                                             NaturalLit(i),
                                             Value::from_builtin(
                                                 Builtin::Natural,
@@ -245,7 +245,7 @@ pub(crate) fn apply_builtin(
                                         ),
                                     );
                                     kvs.insert("value".into(), e.clone());
-                                    Value::from_valuef_and_type(
+                                    Value::from_kind_and_type(
                                         RecordLit(kvs),
                                         t.clone(),
                                     )
@@ -254,14 +254,14 @@ pub(crate) fn apply_builtin(
                         ),
                         _ => unreachable!(),
                     };
-                    Ret::ValueF(list)
+                    Ret::ValueKind(list)
                 }
                 _ => Ret::DoneAsIs,
             }
         }
         (ListBuild, [t, f]) => match &*f.as_whnf() {
             // fold/build fusion
-            ValueF::AppliedBuiltin(ListFold, args) => {
+            ValueKind::AppliedBuiltin(ListFold, args) => {
                 if args.len() >= 2 {
                     Ret::Value(args[1].clone())
                 } else {
@@ -303,7 +303,7 @@ pub(crate) fn apply_builtin(
         },
         (OptionalBuild, [t, f]) => match &*f.as_whnf() {
             // fold/build fusion
-            ValueF::AppliedBuiltin(OptionalFold, args) => {
+            ValueKind::AppliedBuiltin(OptionalFold, args) => {
                 if args.len() >= 2 {
                     Ret::Value(args[1].clone())
                 } else {
@@ -338,7 +338,7 @@ pub(crate) fn apply_builtin(
         },
         (NaturalBuild, [f]) => match &*f.as_whnf() {
             // fold/build fusion
-            ValueF::AppliedBuiltin(NaturalFold, args) => {
+            ValueKind::AppliedBuiltin(NaturalFold, args) => {
                 if !args.is_empty() {
                     Ret::Value(args[0].clone())
                 } else {
@@ -375,7 +375,7 @@ pub(crate) fn apply_builtin(
         _ => Ret::DoneAsIs,
     };
     match ret {
-        Ret::ValueF(v) => v,
+        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();
@@ -388,23 +388,23 @@ pub(crate) fn apply_builtin(
     }
 }
 
-pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueF {
+pub(crate) fn apply_any(f: Value, a: Value, ty: &Value) -> ValueKind {
     let f_borrow = f.as_whnf();
     match &*f_borrow {
-        ValueF::Lam(x, _, e) => {
+        ValueKind::Lam(x, _, e) => {
             e.subst_shift(&x.into(), &a).to_whnf_check_type(ty)
         }
-        ValueF::AppliedBuiltin(b, args) => {
+        ValueKind::AppliedBuiltin(b, args) => {
             use std::iter::once;
             let args = args.iter().cloned().chain(once(a.clone())).collect();
             apply_builtin(*b, args, ty)
         }
-        ValueF::UnionConstructor(l, kts) => {
-            ValueF::UnionLit(l.clone(), a, kts.clone())
+        ValueKind::UnionConstructor(l, kts) => {
+            ValueKind::UnionLit(l.clone(), a, kts.clone())
         }
         _ => {
             drop(f_borrow);
-            ValueF::PartialExpr(ExprF::App(f, a))
+            ValueKind::PartialExpr(ExprF::App(f, a))
         }
     }
 }
@@ -426,7 +426,7 @@ pub(crate) fn squash_textlit(
                 Expr(e) => {
                     let e_borrow = e.as_whnf();
                     match &*e_borrow {
-                        ValueF::TextLit(elts2) => {
+                        ValueKind::TextLit(elts2) => {
                             inner(elts2.iter().cloned(), crnt_str, ret)
                         }
                         _ => {
@@ -479,7 +479,7 @@ where
 
 // Small helper enum to avoid repetition
 enum Ret<'a> {
-    ValueF(ValueF),
+    ValueKind(ValueKind),
     Value(Value),
     ValueRef(&'a Value),
     Expr(ExprF<Value, Normalized>),
@@ -496,7 +496,7 @@ fn apply_binop<'a>(
         NaturalTimes, RecursiveRecordMerge, RecursiveRecordTypeMerge,
         RightBiasedRecordMerge, TextAppend,
     };
-    use ValueF::{
+    use ValueKind::{
         BoolLit, EmptyListLit, NEListLit, NaturalLit, RecordLit, RecordType,
         TextLit,
     };
@@ -505,58 +505,58 @@ fn apply_binop<'a>(
     Some(match (o, &*x_borrow, &*y_borrow) {
         (BoolAnd, BoolLit(true), _) => Ret::ValueRef(y),
         (BoolAnd, _, BoolLit(true)) => Ret::ValueRef(x),
-        (BoolAnd, BoolLit(false), _) => Ret::ValueF(BoolLit(false)),
-        (BoolAnd, _, BoolLit(false)) => Ret::ValueF(BoolLit(false)),
+        (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::ValueF(BoolLit(true)),
-        (BoolOr, _, BoolLit(true)) => Ret::ValueF(BoolLit(true)),
+        (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::ValueF(BoolLit(x == y)),
-        (BoolEQ, _, _) if x == y => Ret::ValueF(BoolLit(true)),
+        (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::ValueF(BoolLit(x != y)),
-        (BoolNE, _, _) if x == y => Ret::ValueF(BoolLit(false)),
+        (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::ValueF(NaturalLit(x + y))
+            Ret::ValueKind(NaturalLit(x + y))
         }
-        (NaturalTimes, NaturalLit(0), _) => Ret::ValueF(NaturalLit(0)),
-        (NaturalTimes, _, NaturalLit(0)) => Ret::ValueF(NaturalLit(0)),
+        (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::ValueF(NaturalLit(x * y))
+            Ret::ValueKind(NaturalLit(x * y))
         }
 
         (ListAppend, EmptyListLit(_), _) => Ret::ValueRef(y),
         (ListAppend, _, EmptyListLit(_)) => Ret::ValueRef(x),
-        (ListAppend, NEListLit(xs), NEListLit(ys)) => Ret::ValueF(NEListLit(
-            xs.iter().chain(ys.iter()).cloned().collect(),
-        )),
+        (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::ValueF(TextLit(
+        (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::ValueF(TextLit(squash_textlit(
+            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::ValueF(TextLit(squash_textlit(
+            Ret::ValueKind(TextLit(squash_textlit(
                 once(x).chain(y.iter().cloned()),
             )))
         }
@@ -573,7 +573,7 @@ fn apply_binop<'a>(
                 // Insert only if key not already present
                 kvs.entry(x.clone()).or_insert_with(|| v.clone());
             }
-            Ret::ValueF(RecordLit(kvs))
+            Ret::ValueKind(RecordLit(kvs))
         }
 
         (RecursiveRecordMerge, _, RecordLit(kvs)) if kvs.is_empty() => {
@@ -589,8 +589,8 @@ fn apply_binop<'a>(
                 _ => unreachable!("Internal type error"),
             };
             let kvs = merge_maps::<_, _, _, !>(kvs1, kvs2, |k, v1, v2| {
-                Ok(Value::from_valuef_and_type(
-                    ValueF::PartialExpr(ExprF::BinOp(
+                Ok(Value::from_kind_and_type(
+                    ValueKind::PartialExpr(ExprF::BinOp(
                         RecursiveRecordMerge,
                         v1.clone(),
                         v2.clone(),
@@ -598,7 +598,7 @@ fn apply_binop<'a>(
                     kts.get(k).expect("Internal type error").clone(),
                 ))
             })?;
-            Ret::ValueF(RecordLit(kvs))
+            Ret::ValueKind(RecordLit(kvs))
         }
 
         (RecursiveRecordTypeMerge, _, _) | (Equivalence, _, _) => {
@@ -612,8 +612,8 @@ fn apply_binop<'a>(
 pub(crate) fn normalize_one_layer(
     expr: ExprF<Value, Normalized>,
     ty: &Value,
-) -> ValueF {
-    use ValueF::{
+) -> ValueKind {
+    use ValueKind::{
         AppliedBuiltin, BoolLit, DoubleLit, EmptyListLit, IntegerLit,
         NEListLit, NEOptionalLit, NaturalLit, RecordLit, TextLit,
         UnionConstructor, UnionLit, UnionType,
@@ -639,17 +639,17 @@ pub(crate) fn normalize_one_layer(
         }
         ExprF::Assert(_) => Ret::Expr(expr),
         ExprF::App(v, a) => Ret::Value(v.app(a)),
-        ExprF::BoolLit(b) => Ret::ValueF(BoolLit(b)),
-        ExprF::NaturalLit(n) => Ret::ValueF(NaturalLit(n)),
-        ExprF::IntegerLit(n) => Ret::ValueF(IntegerLit(n)),
-        ExprF::DoubleLit(n) => Ret::ValueF(DoubleLit(n)),
-        ExprF::SomeLit(e) => Ret::ValueF(NEOptionalLit(e)),
+        ExprF::BoolLit(b) => Ret::ValueKind(BoolLit(b)),
+        ExprF::NaturalLit(n) => Ret::ValueKind(NaturalLit(n)),
+        ExprF::IntegerLit(n) => Ret::ValueKind(IntegerLit(n)),
+        ExprF::DoubleLit(n) => Ret::ValueKind(DoubleLit(n)),
+        ExprF::SomeLit(e) => Ret::ValueKind(NEOptionalLit(e)),
         ExprF::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::ValueF(EmptyListLit(args[0].clone()))
+                    Ret::ValueKind(EmptyListLit(args[0].clone()))
                 }
                 _ => {
                     drop(t_borrow);
@@ -658,10 +658,10 @@ pub(crate) fn normalize_one_layer(
             }
         }
         ExprF::NEListLit(elts) => {
-            Ret::ValueF(NEListLit(elts.into_iter().collect()))
+            Ret::ValueKind(NEListLit(elts.into_iter().collect()))
         }
         ExprF::RecordLit(kvs) => {
-            Ret::ValueF(RecordLit(kvs.into_iter().collect()))
+            Ret::ValueKind(RecordLit(kvs.into_iter().collect()))
         }
         ExprF::TextLit(elts) => {
             use InterpolatedTextContents::Expr;
@@ -670,7 +670,7 @@ pub(crate) fn normalize_one_layer(
             if let [Expr(th)] = elts.as_slice() {
                 Ret::Value(th.clone())
             } else {
-                Ret::ValueF(TextLit(elts))
+                Ret::ValueKind(TextLit(elts))
             }
         }
         ExprF::BoolIf(ref b, ref e1, ref e2) => {
@@ -701,12 +701,12 @@ pub(crate) fn normalize_one_layer(
         },
 
         ExprF::Projection(_, ref ls) if ls.is_empty() => {
-            Ret::ValueF(RecordLit(HashMap::new()))
+            Ret::ValueKind(RecordLit(HashMap::new()))
         }
         ExprF::Projection(ref v, ref ls) => {
             let v_borrow = v.as_whnf();
             match &*v_borrow {
-                RecordLit(kvs) => Ret::ValueF(RecordLit(
+                RecordLit(kvs) => Ret::ValueKind(RecordLit(
                     ls.iter()
                         .filter_map(|l| {
                             kvs.get(l).map(|x| (l.clone(), x.clone()))
@@ -730,7 +730,7 @@ pub(crate) fn normalize_one_layer(
                     }
                 },
                 UnionType(kts) => {
-                    Ret::ValueF(UnionConstructor(l.clone(), kts.clone()))
+                    Ret::ValueKind(UnionConstructor(l.clone(), kts.clone()))
                 }
                 _ => {
                     drop(v_borrow);
@@ -773,20 +773,20 @@ pub(crate) fn normalize_one_layer(
     };
 
     match ret {
-        Ret::ValueF(v) => v,
+        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) => ValueF::PartialExpr(expr),
+        Ret::Expr(expr) => ValueKind::PartialExpr(expr),
     }
 }
 
-/// Normalize a ValueF into WHNF
-pub(crate) fn normalize_whnf(v: ValueF, ty: &Value) -> ValueF {
+/// Normalize a ValueKind into WHNF
+pub(crate) fn normalize_whnf(v: ValueKind, ty: &Value) -> ValueKind {
     match v {
-        ValueF::AppliedBuiltin(b, args) => apply_builtin(b, args, ty),
-        ValueF::PartialExpr(e) => normalize_one_layer(e, ty),
-        ValueF::TextLit(elts) => {
-            ValueF::TextLit(squash_textlit(elts.into_iter()))
+        ValueKind::AppliedBuiltin(b, args) => apply_builtin(b, args, ty),
+        ValueKind::PartialExpr(e) => normalize_one_layer(e, ty),
+        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/phase/typecheck.rs b/dhall/src/semantics/phase/typecheck.rs
index 59380a3..96a0b4b 100644
--- a/dhall/src/semantics/phase/typecheck.rs
+++ b/dhall/src/semantics/phase/typecheck.rs
@@ -3,7 +3,7 @@ use std::collections::HashMap;
 
 use crate::semantics::core::context::TypecheckContext;
 use crate::semantics::core::value::Value;
-use crate::semantics::core::valuef::ValueF;
+use crate::semantics::core::value_kind::ValueKind;
 use crate::semantics::core::var::{Shift, Subst};
 use crate::semantics::error::{TypeError, TypeMessage};
 use crate::semantics::phase::normalize::merge_maps;
@@ -39,8 +39,8 @@ fn tck_pi_type(
 
     let k = function_check(ka, kb);
 
-    Ok(Value::from_valuef_and_type(
-        ValueF::Pi(x.into(), tx, te),
+    Ok(Value::from_kind_and_type(
+        ValueKind::Pi(x.into(), tx, te),
         Value::from_const(k),
     ))
 }
@@ -71,8 +71,8 @@ fn tck_record_type(
         };
     }
 
-    Ok(Value::from_valuef_and_type(
-        ValueF::RecordType(new_kts),
+    Ok(Value::from_kind_and_type(
+        ValueKind::RecordType(new_kts),
         Value::from_const(k),
     ))
 }
@@ -116,8 +116,8 @@ where
     // an union type with only unary variants also has type Type
     let k = k.unwrap_or(Const::Type);
 
-    Ok(Value::from_valuef_and_type(
-        ValueF::UnionType(new_kts),
+    Ok(Value::from_kind_and_type(
+        ValueKind::UnionType(new_kts),
         Value::from_const(k),
     ))
 }
@@ -131,13 +131,13 @@ fn function_check(a: Const, b: Const) -> Const {
 }
 
 pub(crate) fn const_to_value(c: Const) -> Value {
-    let v = ValueF::Const(c);
+    let v = ValueKind::Const(c);
     match c {
         Const::Type => {
-            Value::from_valuef_and_type(v, const_to_value(Const::Kind))
+            Value::from_kind_and_type(v, const_to_value(Const::Kind))
         }
         Const::Kind => {
-            Value::from_valuef_and_type(v, const_to_value(Const::Sort))
+            Value::from_kind_and_type(v, const_to_value(Const::Sort))
         }
         Const::Sort => Value::const_sort(),
     }
@@ -290,8 +290,8 @@ fn type_of_builtin<E>(b: Builtin) -> Expr<E> {
 
 pub(crate) fn builtin_to_value(b: Builtin) -> Value {
     let ctx = TypecheckContext::new();
-    Value::from_valuef_and_type(
-        ValueF::from_builtin(b),
+    Value::from_kind_and_type(
+        ValueKind::from_builtin(b),
         type_with(&ctx, type_of_builtin(b)).unwrap(),
     )
 }
@@ -313,8 +313,8 @@ fn type_with(
             let ctx2 = ctx.insert_type(var, annot.clone());
             let body = type_with(&ctx2, body.clone())?;
             let body_type = body.get_type()?;
-            Value::from_valuef_and_type(
-                ValueF::Lam(var.clone().into(), annot.clone(), body),
+            Value::from_kind_and_type(
+                ValueKind::Lam(var.clone().into(), annot.clone(), body),
                 tck_pi_type(ctx, var.clone(), annot, body_type)?,
             )
         }
@@ -389,7 +389,7 @@ fn type_last_layer(
             let tf = f.get_type()?;
             let tf_borrow = tf.as_whnf();
             let (x, tx, tb) = match &*tf_borrow {
-                ValueF::Pi(x, tx, tb) => (x, tx, tb),
+                ValueKind::Pi(x, tx, tb) => (x, tx, tb),
                 _ => return mkerr(NotAFunction(f.clone())),
             };
             if &a.get_type()? != tx {
@@ -406,8 +406,8 @@ fn type_last_layer(
         }
         Assert(t) => {
             match &*t.as_whnf() {
-                ValueF::Equivalence(x, y) if x == y => {}
-                ValueF::Equivalence(x, y) => {
+                ValueKind::Equivalence(x, y) if x == y => {}
+                ValueKind::Equivalence(x, y) => {
                     return mkerr(AssertMismatch(x.clone(), y.clone()))
                 }
                 _ => return mkerr(AssertMustTakeEquivalence),
@@ -415,7 +415,7 @@ fn type_last_layer(
             RetTypeOnly(t.clone())
         }
         BoolIf(x, y, z) => {
-            if *x.get_type()?.as_whnf() != ValueF::from_builtin(Bool) {
+            if *x.get_type()?.as_whnf() != ValueKind::from_builtin(Bool) {
                 return mkerr(InvalidPredicate(x.clone()));
             }
 
@@ -435,7 +435,7 @@ fn type_last_layer(
         }
         EmptyListLit(t) => {
             match &*t.as_whnf() {
-                ValueF::AppliedBuiltin(syntax::Builtin::List, args)
+                ValueKind::AppliedBuiltin(syntax::Builtin::List, args)
                     if args.len() == 1 => {}
                 _ => return mkerr(InvalidListType(t.clone())),
             }
@@ -482,7 +482,7 @@ fn type_last_layer(
         )?),
         Field(r, x) => {
             match &*r.get_type()?.as_whnf() {
-                ValueF::RecordType(kts) => match kts.get(&x) {
+                ValueKind::RecordType(kts) => match kts.get(&x) {
                     Some(tth) => {
                         RetTypeOnly(tth.clone())
                     },
@@ -492,7 +492,7 @@ fn type_last_layer(
                 // TODO: branch here only when r.get_type() is a Const
                 _ => {
                     match &*r.as_whnf() {
-                        ValueF::UnionType(kts) => match kts.get(&x) {
+                        ValueKind::UnionType(kts) => match kts.get(&x) {
                             // Constructor has type T -> < x: T, ... >
                             Some(Some(t)) => {
                                 RetTypeOnly(
@@ -553,14 +553,14 @@ fn type_last_layer(
             // Extract the LHS record type
             let l_type_borrow = l_type.as_whnf();
             let kts_x = match &*l_type_borrow {
-                ValueF::RecordType(kts) => kts,
+                ValueKind::RecordType(kts) => kts,
                 _ => return mkerr(MustCombineRecord(l.clone())),
             };
 
             // Extract the RHS record type
             let r_type_borrow = r_type.as_whnf();
             let kts_y = match &*r_type_borrow {
-                ValueF::RecordType(kts) => kts,
+                ValueKind::RecordType(kts) => kts,
                 _ => return mkerr(MustCombineRecord(r.clone())),
             };
 
@@ -589,7 +589,7 @@ fn type_last_layer(
             // Extract the LHS record type
             let borrow_l = l.as_whnf();
             let kts_x = match &*borrow_l {
-                ValueF::RecordType(kts) => kts,
+                ValueKind::RecordType(kts) => kts,
                 _ => {
                     return mkerr(RecordTypeMergeRequiresRecordType(l.clone()))
                 }
@@ -598,7 +598,7 @@ fn type_last_layer(
             // Extract the RHS record type
             let borrow_r = r.as_whnf();
             let kts_y = match &*borrow_r {
-                ValueF::RecordType(kts) => kts,
+                ValueKind::RecordType(kts) => kts,
                 _ => {
                     return mkerr(RecordTypeMergeRequiresRecordType(r.clone()))
                 }
@@ -626,7 +626,7 @@ fn type_last_layer(
         }
         BinOp(o @ ListAppend, l, r) => {
             match &*l.get_type()?.as_whnf() {
-                ValueF::AppliedBuiltin(List, _) => {}
+                ValueKind::AppliedBuiltin(List, _) => {}
                 _ => return mkerr(BinOpTypeMismatch(*o, l.clone())),
             }
 
@@ -648,8 +648,8 @@ fn type_last_layer(
                 return mkerr(EquivalenceTypeMismatch(r.clone(), l.clone()));
             }
 
-            RetWhole(Value::from_valuef_and_type(
-                ValueF::Equivalence(l.clone(), r.clone()),
+            RetWhole(Value::from_kind_and_type(
+                ValueKind::Equivalence(l.clone(), r.clone()),
                 Value::from_const(Type),
             ))
         }
@@ -684,14 +684,14 @@ fn type_last_layer(
             let record_type = record.get_type()?;
             let record_borrow = record_type.as_whnf();
             let handlers = match &*record_borrow {
-                ValueF::RecordType(kts) => kts,
+                ValueKind::RecordType(kts) => kts,
                 _ => return mkerr(Merge1ArgMustBeRecord(record.clone())),
             };
 
             let union_type = union.get_type()?;
             let union_borrow = union_type.as_whnf();
             let variants = match &*union_borrow {
-                ValueF::UnionType(kts) => kts,
+                ValueKind::UnionType(kts) => kts,
                 _ => return mkerr(Merge2ArgMustBeUnion(union.clone())),
             };
 
@@ -703,7 +703,7 @@ fn type_last_layer(
                         Some(Some(variant_type)) => {
                             let handler_type_borrow = handler_type.as_whnf();
                             let (x, tx, tb) = match &*handler_type_borrow {
-                                ValueF::Pi(x, tx, tb) => (x, tx, tb),
+                                ValueKind::Pi(x, tx, tb) => (x, tx, tb),
                                 _ => {
                                     return mkerr(NotAFunction(
                                         handler_type.clone(),
@@ -765,7 +765,7 @@ fn type_last_layer(
             let record_type = record.get_type()?;
             let record_type_borrow = record_type.as_whnf();
             let kts = match &*record_type_borrow {
-                ValueF::RecordType(kts) => kts,
+                ValueKind::RecordType(kts) => kts,
                 _ => return mkerr(ProjectionMustBeRecord),
             };
 
@@ -777,8 +777,8 @@ fn type_last_layer(
                 };
             }
 
-            RetTypeOnly(Value::from_valuef_and_type(
-                ValueF::RecordType(new_kts),
+            RetTypeOnly(Value::from_kind_and_type(
+                ValueKind::RecordType(new_kts),
                 record_type.get_type()?,
             ))
         }
@@ -786,8 +786,8 @@ fn type_last_layer(
     };
 
     Ok(match ret {
-        RetTypeOnly(typ) => Value::from_valuef_and_type_and_span(
-            ValueF::PartialExpr(e),
+        RetTypeOnly(typ) => Value::from_kind_and_type_and_span(
+            ValueKind::PartialExpr(e),
             typ,
             span,
         ),