1 files changed, 36 insertions, 14 deletions
diff --git a/dhall/src/phase/normalize.rs b/dhall/src/phase/normalize.rs
index 35d32cb..395cf28 100644
--- a/dhall/src/phase/normalize.rs
+++ b/dhall/src/phase/normalize.rs
@@ -47,6 +47,16 @@ pub fn apply_builtin(b: Builtin, args: Vec<Thunk>) -> Value {
             )),
             _ => Err(()),
         },
+        (NaturalSubtract, [a, b, r..]) => {
+            match (&*a.as_value(), &*b.as_value()) {
+                (NaturalLit(a), NaturalLit(b)) => {
+                    Ok((r, NaturalLit(if b > a { b - a } else { 0 })))
+                }
+                (NaturalLit(0), b) => Ok((r, b.clone())),
+                (_, NaturalLit(0)) => Ok((r, NaturalLit(0))),
+                _ => Err(()),
+            }
+        }
         (IntegerShow, [n, r..]) => match &*n.as_value() {
             IntegerLit(n) => {
                 let s = if *n < 0 {
@@ -72,6 +82,17 @@ pub fn apply_builtin(b: Builtin, args: Vec<Thunk>) -> Value {
         (TextShow, [v, r..]) => match &*v.as_value() {
             TextLit(elts) => {
                 match elts.as_slice() {
+                    // Empty string literal.
+                    [] => {
+                        // Printing InterpolatedText takes care of all the escaping
+                        let txt: InterpolatedText<X> =
+                            std::iter::empty().collect();
+                        let s = txt.to_string();
+                        Ok((
+                            r,
+                            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)] => {
@@ -611,7 +632,7 @@ fn apply_binop<'a>(o: BinOp, x: &'a Thunk, y: &'a Thunk) -> Option<Ret<'a>> {
 
 pub fn normalize_one_layer(expr: ExprF<Thunk, X>) -> Value {
     use Value::{
-        BoolLit, DoubleLit, EmptyListLit, EmptyOptionalLit, IntegerLit, Lam,
+        AppliedBuiltin, BoolLit, DoubleLit, EmptyListLit, IntegerLit, Lam,
         NEListLit, NEOptionalLit, NaturalLit, Pi, RecordLit, RecordType,
         TextLit, UnionConstructor, UnionLit, UnionType,
     };
@@ -639,13 +660,21 @@ pub fn normalize_one_layer(expr: ExprF<Thunk, X>) -> Value {
         ExprF::NaturalLit(n) => Ret::Value(NaturalLit(n)),
         ExprF::IntegerLit(n) => Ret::Value(IntegerLit(n)),
         ExprF::DoubleLit(n) => Ret::Value(DoubleLit(n)),
-        ExprF::OldOptionalLit(None, t) => {
-            Ret::Value(EmptyOptionalLit(TypeThunk::from_thunk(t)))
-        }
-        ExprF::OldOptionalLit(Some(e), _) => Ret::Value(NEOptionalLit(e)),
         ExprF::SomeLit(e) => Ret::Value(NEOptionalLit(e)),
-        ExprF::EmptyListLit(t) => {
-            Ret::Value(EmptyListLit(TypeThunk::from_thunk(t)))
+        ExprF::EmptyListLit(ref t) => {
+            // Check if the type is of the form `List x`
+            let t_borrow = t.as_value();
+            match &*t_borrow {
+                AppliedBuiltin(Builtin::List, args) if args.len() == 1 => {
+                    Ret::Value(EmptyListLit(TypeThunk::from_thunk(
+                        args[0].clone(),
+                    )))
+                }
+                _ => {
+                    drop(t_borrow);
+                    Ret::Expr(expr)
+                }
+            }
         }
         ExprF::NEListLit(elts) => {
             Ret::Value(NEListLit(elts.into_iter().collect()))
@@ -658,13 +687,6 @@ pub fn normalize_one_layer(expr: ExprF<Thunk, X>) -> Value {
                 .map(|(k, t)| (k, TypeThunk::from_thunk(t)))
                 .collect(),
         )),
-        ExprF::UnionLit(l, x, kts) => Ret::Value(UnionLit(
-            l,
-            x,
-            kts.into_iter()
-                .map(|(k, t)| (k, t.map(|t| TypeThunk::from_thunk(t))))
-                .collect(),
-        )),
         ExprF::UnionType(kts) => Ret::Value(UnionType(
             kts.into_iter()
                 .map(|(k, t)| (k, t.map(|t| TypeThunk::from_thunk(t))))