From f4a50a5da10eb2de1d7cf00ad6f6765605da366d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 18 Apr 2019 17:29:17 +0200
Subject: Make normalize manipulate SubExprs more directly

---
 dhall/src/normalize.rs | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 1561f01..80c2e9a 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -150,7 +150,7 @@ where
         ),
         // // fold/build fusion
         // (ListFold, [_, App(box Builtin(ListBuild), [_, x, rest..]), rest..]) => {
-        //     normalize_ref(&App(bx(x.clone()), rest.to_vec()))
+        //     normalize_value(&App(bx(x.clone()), rest.to_vec()))
         // }
         (OptionalFold, [_, NEOptionalLit(x), _, just, _, rest..]) => {
             let x = x.clone();
@@ -162,7 +162,7 @@ where
         }
         // // fold/build fusion
         // (OptionalFold, [_, App(box Builtin(OptionalBuild), [_, x, rest..]), rest..]) => {
-        //     normalize_ref(&App(bx(x.clone()), rest.to_vec()))
+        //     normalize_value(&App(bx(x.clone()), rest.to_vec()))
         // }
         (NaturalBuild, [g, rest..]) => {
             'ret: {
@@ -226,12 +226,12 @@ enum WhatNext<'a, N, E> {
     DoneAsIs,
 }
 
-fn normalize_ref(expr: &Expr<X, Normalized<'static>>) -> Expr<X, X> {
+fn normalize_value(expr: SubExpr<X, Normalized<'static>>) -> SubExpr<X, X> {
     use dhall_core::BinOp::*;
     use dhall_core::ExprF::*;
     // Recursively normalize all subexpressions
     let expr: ExprF<Expr<X, X>, Label, X, Normalized<'static>> =
-        expr.map_ref_simple(|e| normalize_ref(e.as_ref()));
+        expr.as_ref().map_ref_simple(|e| normalize_value(e.clone()).unroll());
 
     use WhatNext::*;
     // TODO: match by move
@@ -325,17 +325,17 @@ fn normalize_ref(expr: &Expr<X, Normalized<'static>>) -> Expr<X, X> {
     };
 
     match what_next {
-        Continue(e) => normalize_ref(&e.embed_absurd()),
-        ContinueSub(e) => normalize_ref(e.embed_absurd().as_ref()),
-        Done(e) => e,
-        DoneRef(e) => e.clone(),
-        DoneRefSub(e) => e.unroll(),
-        DoneAsIs => expr.map_ref_simple(ExprF::roll).map_ref(
+        Continue(e) => normalize_value(e.embed_absurd().roll()),
+        ContinueSub(e) => normalize_value(e.embed_absurd()),
+        Done(e) => e.roll(),
+        DoneRef(e) => e.roll(),
+        DoneRefSub(e) => e.clone(),
+        DoneAsIs => rc(expr.map_ref_simple(ExprF::roll).map_ref(
             SubExpr::clone,
             X::clone,
             |_| unreachable!(),
             Label::clone,
-        ),
+        )),
     }
 }
 
@@ -349,7 +349,7 @@ fn normalize_ref(expr: &Expr<X, Normalized<'static>>) -> Expr<X, X> {
 /// leave ill-typed sub-expressions unevaluated.
 ///
 fn normalize(e: SubExpr<X, Normalized<'static>>) -> SubExpr<X, X> {
-    normalize_ref(e.as_ref()).roll()
+    normalize_value(e)
 }
 
 #[cfg(test)]
-- 
cgit v1.2.3


From 588127bf4105d8d4629304521abc3d992326a63a Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 18 Apr 2019 19:34:38 +0200
Subject: subst_shift in a single pass

---
 dhall/src/typecheck.rs | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/typecheck.rs b/dhall/src/typecheck.rs
index 5aaeb08..186384d 100644
--- a/dhall/src/typecheck.rs
+++ b/dhall/src/typecheck.rs
@@ -44,9 +44,9 @@ impl<'a> Normalized<'a> {
     fn unroll_ref(&self) -> &Expr<X, X> {
         self.as_expr().as_ref()
     }
-    fn shift(&self, delta: isize, var: &V<Label>) -> Self {
+    fn shift0(&self, delta: isize, label: &Label) -> Self {
         // shift the type too ?
-        Normalized(shift(delta, var, &self.0), self.1.clone(), self.2)
+        Normalized(shift0(delta, label, &self.0), self.1.clone(), self.2)
     }
 }
 impl Normalized<'static> {
@@ -86,10 +86,10 @@ impl<'a> Type<'a> {
             Cow::Owned(e) => Ok(Cow::Owned(e.into_expr().unroll())),
         }
     }
-    fn shift(&self, delta: isize, var: &V<Label>) -> Self {
+    fn shift0(&self, delta: isize, label: &Label) -> Self {
         use TypeInternal::*;
         Type(match &self.0 {
-            Expr(e) => Expr(Box::new(e.shift(delta, var))),
+            Expr(e) => Expr(Box::new(e.shift0(delta, label))),
             Const(c) => Const(*c),
             SuperType => SuperType,
         })
@@ -378,9 +378,7 @@ fn type_with(
     let ret = match e.as_ref() {
         Lam(x, t, b) => {
             let t = mktype(ctx, t.clone())?;
-            let ctx2 = ctx
-                .insert(x.clone(), t.clone())
-                .map(|e| e.shift(1, &V(x.clone(), 0)));
+            let ctx2 = ctx.insert(x.clone(), t.clone()).map(|e| e.shift0(1, x));
             let b = type_with(&ctx2, b.clone())?;
             Ok(RetExpr(Pi(
                 x.clone(),
@@ -395,9 +393,8 @@ fn type_with(
                 mkerr(InvalidInputType(ta.into_normalized()?)),
             );
 
-            let ctx2 = ctx
-                .insert(x.clone(), ta.clone())
-                .map(|e| e.shift(1, &V(x.clone(), 0)));
+            let ctx2 =
+                ctx.insert(x.clone(), ta.clone()).map(|e| e.shift0(1, x));
             let tb = type_with(&ctx2, tb.clone())?;
             let kB = ensure_is_const!(
                 &tb.get_type()?,
-- 
cgit v1.2.3


From 486a26eb7cea0c99818fde2c3fd933f7aca40b52 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 18 Apr 2019 22:08:25 +0200
Subject: Use a context for substitution in normalization

---
 dhall/src/normalize.rs | 286 ++++++++++++++++++++++++++++++-------------------
 1 file changed, 177 insertions(+), 109 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 80c2e9a..4dc5156 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -1,8 +1,11 @@
 #![allow(non_snake_case)]
-use crate::expr::*;
+use std::fmt;
+
+use dhall_core::context::Context;
 use dhall_core::*;
 use dhall_generator as dhall;
-use std::fmt;
+
+use crate::expr::*;
 
 impl<'a> Typed<'a> {
     pub fn normalize(self) -> Normalized<'a> {
@@ -97,7 +100,7 @@ where
                     }
                 };
                 let a0 = a0.roll();
-                let a1 = shift(1, &V("x".into(), 0), &a0);
+                let a1 = shift0(1, &"x".into(), &a0);
                 let g = g.roll();
                 break 'ret (
                     dhall::subexpr!(
@@ -217,125 +220,190 @@ where
 enum WhatNext<'a, N, E> {
     // Recurse on this expression
     Continue(Expr<N, E>),
-    ContinueSub(SubExpr<N, E>),
     // The following expression is the normal form
     Done(Expr<N, E>),
     DoneRef(&'a Expr<N, E>),
+    DoneSub(SubExpr<N, E>),
     DoneRefSub(&'a SubExpr<N, E>),
     // The current expression is already in normal form
     DoneAsIs,
 }
 
-fn normalize_value(expr: SubExpr<X, Normalized<'static>>) -> SubExpr<X, X> {
-    use dhall_core::BinOp::*;
-    use dhall_core::ExprF::*;
-    // Recursively normalize all subexpressions
-    let expr: ExprF<Expr<X, X>, Label, X, Normalized<'static>> =
-        expr.as_ref().map_ref_simple(|e| normalize_value(e.clone()).unroll());
+#[derive(Debug, Clone)]
+enum EnvItem {
+    Expr(SubExpr<X, X>),
+    Skip(Label, usize),
+}
 
-    use WhatNext::*;
-    // TODO: match by move
-    let what_next = match &expr {
-        Let(f, _, r, b) => {
-            let vf0 = &V(f.clone(), 0);
-            // TODO: use a context
-            ContinueSub(subst_shift(vf0, &r.roll(), &b.roll()))
+impl EnvItem {
+    fn shift0(&self, delta: isize, label: &Label) -> Self {
+        use EnvItem::*;
+        match self {
+            Expr(e) => Expr(shift0(delta, label, e)),
+            Skip(l, n) if l == label => Skip(l.clone(), *n + 1),
+            Skip(l, n) => Skip(l.clone(), *n),
         }
-        Annot(x, _) => DoneRef(x),
-        Note(_, e) => DoneRef(e),
-        App(f, args) if args.is_empty() => DoneRef(f),
-        App(App(f, args1), args2) => Continue(App(
-            f.clone(),
-            args1
-                .iter()
-                .cloned()
-                .chain(args2.iter().map(ExprF::roll))
-                .collect(),
-        )),
-        App(Builtin(b), args) => apply_builtin(*b, args),
-        App(Lam(x, _, b), args) => {
-            let mut iter = args.iter();
-            // We know args is nonempty
-            let a = iter.next().unwrap();
-            // Beta reduce
-            let vx0 = &V(x.clone(), 0);
-            let b2 = subst_shift(vx0, &a.roll(), &b);
-            Continue(App(b2, iter.map(ExprF::roll).collect()))
-        }
-        App(UnionConstructor(l, kts), args) => {
-            let mut iter = args.iter();
-            // We know args is nonempty
-            let a = iter.next().unwrap();
-            let e = rc(UnionLit(l.clone(), rc(a.clone()), kts.clone()));
-            Continue(App(e, iter.map(ExprF::roll).collect()))
-        }
-        BoolIf(BoolLit(true), t, _) => DoneRef(t),
-        BoolIf(BoolLit(false), _, f) => DoneRef(f),
-        // TODO: interpolation
-        // TextLit(t) =>
-        OldOptionalLit(None, t) => Done(EmptyOptionalLit(t.roll())),
-        OldOptionalLit(Some(x), _) => Done(NEOptionalLit(x.roll())),
-        BinOp(BoolAnd, BoolLit(x), BoolLit(y)) => Done(BoolLit(*x && *y)),
-        BinOp(BoolOr, BoolLit(x), BoolLit(y)) => Done(BoolLit(*x || *y)),
-        BinOp(BoolEQ, BoolLit(x), BoolLit(y)) => Done(BoolLit(x == y)),
-        BinOp(BoolNE, BoolLit(x), BoolLit(y)) => Done(BoolLit(x != y)),
-        BinOp(NaturalPlus, NaturalLit(x), NaturalLit(y)) => {
-            Done(NaturalLit(x + y))
-        }
-        BinOp(NaturalTimes, NaturalLit(x), NaturalLit(y)) => {
-            Done(NaturalLit(x * y))
-        }
-        BinOp(TextAppend, TextLit(x), TextLit(y)) => Done(TextLit(x + y)),
-        BinOp(ListAppend, EmptyListLit(_), y) => DoneRef(y),
-        BinOp(ListAppend, x, EmptyListLit(_)) => DoneRef(x),
-        BinOp(ListAppend, NEListLit(xs), NEListLit(ys)) => {
-            let xs = xs.iter().cloned();
-            let ys = ys.iter().cloned();
-            Done(NEListLit(xs.chain(ys).collect()))
+    }
+}
+
+struct NormalizationContext(Context<Label, EnvItem>);
+
+impl NormalizationContext {
+    fn new() -> NormalizationContext {
+        NormalizationContext(Context::new())
+    }
+    fn insert(&self, x: &Label, e: SubExpr<X, X>) -> NormalizationContext {
+        NormalizationContext(self.0.insert(x.clone(), EnvItem::Expr(e)))
+    }
+    fn skip(&self, x: &Label) -> NormalizationContext {
+        NormalizationContext(
+            self.0
+                .map(|e| e.shift0(1, x))
+                .insert(x.clone(), EnvItem::Skip(x.clone(), 0)),
+        )
+    }
+    fn lookup(&self, var: &V<Label>) -> SubExpr<X, X> {
+        let V(x, n) = var;
+        match self.0.lookup(x, *n) {
+            Some(EnvItem::Expr(e)) => e.clone(),
+            Some(EnvItem::Skip(_, m)) => rc(ExprF::Var(V(x.clone(), *m))),
+            None => rc(ExprF::Var(V(x.clone(), *n))),
         }
-        Merge(RecordLit(handlers), UnionLit(l, v, _), _) => {
-            match handlers.get(&l) {
-                Some(h) => Continue(App(h.clone(), vec![v.clone()])),
-                None => DoneAsIs,
-            }
+    }
+}
+
+fn normalize_value(
+    ctx: &NormalizationContext,
+    expr: SubExpr<X, Normalized<'static>>,
+) -> SubExpr<X, X> {
+    use dhall_core::BinOp::*;
+    use dhall_core::ExprF::*;
+
+    match expr.as_ref() {
+        Let(x, _, r, b) => {
+            let r = normalize_value(ctx, r.clone());
+            normalize_value(&ctx.insert(x, r.clone()), b.clone())
         }
-        Merge(RecordLit(handlers), UnionConstructor(l, _), _) => {
-            match handlers.get(&l) {
-                Some(h) => DoneRefSub(h),
-                None => DoneAsIs,
+        e => {
+            // Recursively normalize all subexpressions
+            let expr: ExprF<Expr<X, X>, Label, X, Normalized<'static>> = e
+                .map_ref_with_special_handling_of_binders(
+                    |e| normalize_value(ctx, e.clone()).unroll(),
+                    |x, e| normalize_value(&ctx.skip(x), e.clone()).unroll(),
+                    X::clone,
+                    Normalized::clone,
+                    Label::clone,
+                );
+
+            use WhatNext::*;
+            let what_next = match &expr {
+                Let(_, _, _, _) => unreachable!(),
+                Embed(e) => DoneRefSub(&e.0),
+                Var(v) => DoneSub(ctx.lookup(v)),
+                Annot(x, _) => DoneRef(x),
+                Note(_, e) => DoneRef(e),
+                App(f, args) if args.is_empty() => DoneRef(f),
+                App(App(f, args1), args2) => Continue(App(
+                    f.clone(),
+                    args1
+                        .iter()
+                        .cloned()
+                        .chain(args2.iter().map(ExprF::roll))
+                        .collect(),
+                )),
+                App(Builtin(b), args) => apply_builtin(*b, args),
+                App(Lam(x, _, b), args) => {
+                    let mut iter = args.iter();
+                    // We know args is nonempty
+                    let a = iter.next().unwrap();
+                    // Beta reduce
+                    let vx0 = &V(x.clone(), 0);
+                    let b2 = subst_shift(vx0, &a.roll(), &b);
+                    Continue(App(b2, iter.map(ExprF::roll).collect()))
+                }
+                App(UnionConstructor(l, kts), args) => {
+                    let mut iter = args.iter();
+                    // We know args is nonempty
+                    let a = iter.next().unwrap();
+                    let e = rc(UnionLit(l.clone(), rc(a.clone()), kts.clone()));
+                    Continue(App(e, iter.map(ExprF::roll).collect()))
+                }
+                BoolIf(BoolLit(true), t, _) => DoneRef(t),
+                BoolIf(BoolLit(false), _, f) => DoneRef(f),
+                // TODO: interpolation
+                // TextLit(t) =>
+                OldOptionalLit(None, t) => Done(EmptyOptionalLit(t.roll())),
+                OldOptionalLit(Some(x), _) => Done(NEOptionalLit(x.roll())),
+                BinOp(BoolAnd, BoolLit(x), BoolLit(y)) => {
+                    Done(BoolLit(*x && *y))
+                }
+                BinOp(BoolOr, BoolLit(x), BoolLit(y)) => {
+                    Done(BoolLit(*x || *y))
+                }
+                BinOp(BoolEQ, BoolLit(x), BoolLit(y)) => Done(BoolLit(x == y)),
+                BinOp(BoolNE, BoolLit(x), BoolLit(y)) => Done(BoolLit(x != y)),
+                BinOp(NaturalPlus, NaturalLit(x), NaturalLit(y)) => {
+                    Done(NaturalLit(x + y))
+                }
+                BinOp(NaturalTimes, NaturalLit(x), NaturalLit(y)) => {
+                    Done(NaturalLit(x * y))
+                }
+                BinOp(TextAppend, TextLit(x), TextLit(y)) => {
+                    Done(TextLit(x + y))
+                }
+                BinOp(ListAppend, EmptyListLit(_), y) => DoneRef(y),
+                BinOp(ListAppend, x, EmptyListLit(_)) => DoneRef(x),
+                BinOp(ListAppend, NEListLit(xs), NEListLit(ys)) => {
+                    let xs = xs.iter().cloned();
+                    let ys = ys.iter().cloned();
+                    Done(NEListLit(xs.chain(ys).collect()))
+                }
+                Merge(RecordLit(handlers), UnionLit(l, v, _), _) => {
+                    match handlers.get(&l) {
+                        Some(h) => Continue(App(h.clone(), vec![v.clone()])),
+                        None => DoneAsIs,
+                    }
+                }
+                Merge(RecordLit(handlers), UnionConstructor(l, _), _) => {
+                    match handlers.get(&l) {
+                        Some(h) => DoneRefSub(h),
+                        None => DoneAsIs,
+                    }
+                }
+                Field(RecordLit(kvs), l) => match kvs.get(&l) {
+                    Some(r) => DoneRefSub(r),
+                    None => DoneAsIs,
+                },
+                Field(UnionType(kts), l) => {
+                    Done(UnionConstructor(l.clone(), kts.clone()))
+                }
+                Projection(_, ls) if ls.is_empty() => {
+                    Done(RecordLit(std::collections::BTreeMap::new()))
+                }
+                Projection(RecordLit(kvs), ls) => Done(RecordLit(
+                    ls.iter()
+                        .filter_map(|l| {
+                            kvs.get(l).map(|x| (l.clone(), x.clone()))
+                        })
+                        .collect(),
+                )),
+                _ => DoneAsIs,
+            };
+
+            match what_next {
+                Continue(e) => normalize_value(ctx, e.embed_absurd().roll()),
+                Done(e) => e.roll(),
+                DoneRef(e) => e.roll(),
+                DoneSub(e) => e,
+                DoneRefSub(e) => e.clone(),
+                DoneAsIs => rc(expr.map_ref_simple(ExprF::roll).map_ref(
+                    SubExpr::clone,
+                    X::clone,
+                    |_| unreachable!(),
+                    Label::clone,
+                )),
             }
         }
-        Field(RecordLit(kvs), l) => match kvs.get(&l) {
-            Some(r) => DoneRefSub(r),
-            None => DoneAsIs,
-        },
-        Field(UnionType(kts), l) => {
-            Done(UnionConstructor(l.clone(), kts.clone()))
-        }
-        Projection(_, ls) if ls.is_empty() => {
-            Done(RecordLit(std::collections::BTreeMap::new()))
-        }
-        Projection(RecordLit(kvs), ls) => Done(RecordLit(
-            ls.iter()
-                .filter_map(|l| kvs.get(l).map(|x| (l.clone(), x.clone())))
-                .collect(),
-        )),
-        Embed(e) => DoneRefSub(&e.0),
-        _ => DoneAsIs,
-    };
-
-    match what_next {
-        Continue(e) => normalize_value(e.embed_absurd().roll()),
-        ContinueSub(e) => normalize_value(e.embed_absurd()),
-        Done(e) => e.roll(),
-        DoneRef(e) => e.roll(),
-        DoneRefSub(e) => e.clone(),
-        DoneAsIs => rc(expr.map_ref_simple(ExprF::roll).map_ref(
-            SubExpr::clone,
-            X::clone,
-            |_| unreachable!(),
-            Label::clone,
-        )),
     }
 }
 
@@ -349,7 +417,7 @@ fn normalize_value(expr: SubExpr<X, Normalized<'static>>) -> SubExpr<X, X> {
 /// leave ill-typed sub-expressions unevaluated.
 ///
 fn normalize(e: SubExpr<X, Normalized<'static>>) -> SubExpr<X, X> {
-    normalize_value(e)
+    normalize_value(&NormalizationContext::new(), e)
 }
 
 #[cfg(test)]
-- 
cgit v1.2.3


From 0682a84eadc383e1d5747576298c9160737e0e99 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 18 Apr 2019 22:20:40 +0200
Subject: Label is redundant in EnvItem::Skip

---
 dhall/src/normalize.rs | 52 +++++++++++++++++++++++---------------------------
 dhall/src/typecheck.rs |  5 +++--
 2 files changed, 27 insertions(+), 30 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 4dc5156..7a9ca2f 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -216,34 +216,10 @@ where
     Continue(ExprF::App(ret, rest))
 }
 
-// Small enum to help with being DRY
-enum WhatNext<'a, N, E> {
-    // Recurse on this expression
-    Continue(Expr<N, E>),
-    // The following expression is the normal form
-    Done(Expr<N, E>),
-    DoneRef(&'a Expr<N, E>),
-    DoneSub(SubExpr<N, E>),
-    DoneRefSub(&'a SubExpr<N, E>),
-    // The current expression is already in normal form
-    DoneAsIs,
-}
-
 #[derive(Debug, Clone)]
 enum EnvItem {
     Expr(SubExpr<X, X>),
-    Skip(Label, usize),
-}
-
-impl EnvItem {
-    fn shift0(&self, delta: isize, label: &Label) -> Self {
-        use EnvItem::*;
-        match self {
-            Expr(e) => Expr(shift0(delta, label, e)),
-            Skip(l, n) if l == label => Skip(l.clone(), *n + 1),
-            Skip(l, n) => Skip(l.clone(), *n),
-        }
-    }
+    Skip(usize),
 }
 
 struct NormalizationContext(Context<Label, EnvItem>);
@@ -258,20 +234,40 @@ impl NormalizationContext {
     fn skip(&self, x: &Label) -> NormalizationContext {
         NormalizationContext(
             self.0
-                .map(|e| e.shift0(1, x))
-                .insert(x.clone(), EnvItem::Skip(x.clone(), 0)),
+                .map(|l, e| {
+                    use EnvItem::*;
+                    match e {
+                        Expr(e) => Expr(shift0(1, x, e)),
+                        Skip(n) if l == x => Skip(*n + 1),
+                        Skip(n) => Skip(*n),
+                    }
+                })
+                .insert(x.clone(), EnvItem::Skip(0)),
         )
     }
     fn lookup(&self, var: &V<Label>) -> SubExpr<X, X> {
         let V(x, n) = var;
         match self.0.lookup(x, *n) {
             Some(EnvItem::Expr(e)) => e.clone(),
-            Some(EnvItem::Skip(_, m)) => rc(ExprF::Var(V(x.clone(), *m))),
+            Some(EnvItem::Skip(m)) => rc(ExprF::Var(V(x.clone(), *m))),
             None => rc(ExprF::Var(V(x.clone(), *n))),
         }
     }
 }
 
+// Small enum to help with being DRY
+enum WhatNext<'a, N, E> {
+    // Recurse on this expression
+    Continue(Expr<N, E>),
+    // The following expression is the normal form
+    Done(Expr<N, E>),
+    DoneRef(&'a Expr<N, E>),
+    DoneSub(SubExpr<N, E>),
+    DoneRefSub(&'a SubExpr<N, E>),
+    // The current expression is already in normal form
+    DoneAsIs,
+}
+
 fn normalize_value(
     ctx: &NormalizationContext,
     expr: SubExpr<X, Normalized<'static>>,
diff --git a/dhall/src/typecheck.rs b/dhall/src/typecheck.rs
index 186384d..65128cd 100644
--- a/dhall/src/typecheck.rs
+++ b/dhall/src/typecheck.rs
@@ -378,7 +378,8 @@ fn type_with(
     let ret = match e.as_ref() {
         Lam(x, t, b) => {
             let t = mktype(ctx, t.clone())?;
-            let ctx2 = ctx.insert(x.clone(), t.clone()).map(|e| e.shift0(1, x));
+            let ctx2 =
+                ctx.insert(x.clone(), t.clone()).map(|_, e| e.shift0(1, x));
             let b = type_with(&ctx2, b.clone())?;
             Ok(RetExpr(Pi(
                 x.clone(),
@@ -394,7 +395,7 @@ fn type_with(
             );
 
             let ctx2 =
-                ctx.insert(x.clone(), ta.clone()).map(|e| e.shift0(1, x));
+                ctx.insert(x.clone(), ta.clone()).map(|_, e| e.shift0(1, x));
             let tb = type_with(&ctx2, tb.clone())?;
             let kB = ensure_is_const!(
                 &tb.get_type()?,
-- 
cgit v1.2.3


From b0013503e06da01bec78b2957aeffc5115c5f53d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 19 Apr 2019 00:31:42 +0200
Subject: Start separating normalized values from syntactic expressions

---
 dhall/src/lib.rs       |   1 +
 dhall/src/normalize.rs | 299 +++++++++++++++++++++++++++++--------------------
 2 files changed, 179 insertions(+), 121 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/lib.rs b/dhall/src/lib.rs
index 544df6e..c85b962 100644
--- a/dhall/src/lib.rs
+++ b/dhall/src/lib.rs
@@ -3,6 +3,7 @@
 #![feature(slice_patterns)]
 #![feature(label_break_value)]
 #![feature(non_exhaustive)]
+#![feature(bind_by_move_pattern_guards)]
 #![cfg_attr(test, feature(custom_inner_attributes))]
 #![allow(
     clippy::type_complexity,
diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 7a9ca2f..90c6841 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -216,6 +216,39 @@ where
     Continue(ExprF::App(ret, rest))
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum Value {
+    Expr(SubExpr<X, X>),
+    Lam(
+        Label,
+        SubExpr<X, Normalized<'static>>,
+        SubExpr<X, Normalized<'static>>,
+    ),
+    // App(
+    //     SubExpr<X, Normalized<'static>>,
+    //     Vec<SubExpr<X, Normalized<'static>>>,
+    // ),
+}
+
+impl Value {
+    fn into_expr(self, ctx: &NormalizationContext) -> SubExpr<X, X> {
+        match self {
+            Value::Expr(e) => e,
+            Value::Lam(x, t, e) => rc(ExprF::Lam(
+                x.clone(),
+                normalize_value(ctx, t).into_expr(ctx),
+                normalize_value(&ctx.skip(&x), e).into_expr(&ctx.skip(&x)),
+            )),
+            // Value::App(f, args) => rc(ExprF::App(
+            //     normalize_value(ctx, f).into_expr(ctx),
+            //     args.into_iter()
+            //         .map(|e| normalize_value(ctx, e).into_expr(ctx))
+            //         .collect(),
+            // )),
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 enum EnvItem {
     Expr(SubExpr<X, X>),
@@ -268,138 +301,161 @@ enum WhatNext<'a, N, E> {
     DoneAsIs,
 }
 
+fn reval(expr: SubExpr<X, X>) -> Value {
+    match expr.as_ref() {
+        ExprF::Lam(x, t, e) => {
+            Value::Lam(x.clone(), t.embed_absurd(), e.embed_absurd())
+        }
+        _ => Value::Expr(expr),
+    }
+}
+
 fn normalize_value(
     ctx: &NormalizationContext,
     expr: SubExpr<X, Normalized<'static>>,
-) -> SubExpr<X, X> {
+) -> Value {
     use dhall_core::BinOp::*;
     use dhall_core::ExprF::*;
 
-    match expr.as_ref() {
+    let e = match expr.as_ref() {
         Let(x, _, r, b) => {
-            let r = normalize_value(ctx, r.clone());
-            normalize_value(&ctx.insert(x, r.clone()), b.clone())
-        }
-        e => {
-            // Recursively normalize all subexpressions
-            let expr: ExprF<Expr<X, X>, Label, X, Normalized<'static>> = e
-                .map_ref_with_special_handling_of_binders(
-                    |e| normalize_value(ctx, e.clone()).unroll(),
-                    |x, e| normalize_value(&ctx.skip(x), e.clone()).unroll(),
-                    X::clone,
-                    Normalized::clone,
-                    Label::clone,
-                );
+            let r = normalize_value(ctx, r.clone()).into_expr(ctx);
+            return normalize_value(&ctx.insert(x, r.clone()), b.clone());
+        }
+        Lam(x, t, e) => return Value::Lam(x.clone(), t.clone(), e.clone()),
+        e => e,
+    };
 
-            use WhatNext::*;
-            let what_next = match &expr {
-                Let(_, _, _, _) => unreachable!(),
-                Embed(e) => DoneRefSub(&e.0),
-                Var(v) => DoneSub(ctx.lookup(v)),
-                Annot(x, _) => DoneRef(x),
-                Note(_, e) => DoneRef(e),
-                App(f, args) if args.is_empty() => DoneRef(f),
-                App(App(f, args1), args2) => Continue(App(
-                    f.clone(),
-                    args1
-                        .iter()
-                        .cloned()
-                        .chain(args2.iter().map(ExprF::roll))
-                        .collect(),
-                )),
-                App(Builtin(b), args) => apply_builtin(*b, args),
-                App(Lam(x, _, b), args) => {
-                    let mut iter = args.iter();
-                    // We know args is nonempty
-                    let a = iter.next().unwrap();
-                    // Beta reduce
-                    let vx0 = &V(x.clone(), 0);
-                    let b2 = subst_shift(vx0, &a.roll(), &b);
-                    Continue(App(b2, iter.map(ExprF::roll).collect()))
-                }
-                App(UnionConstructor(l, kts), args) => {
-                    let mut iter = args.iter();
-                    // We know args is nonempty
-                    let a = iter.next().unwrap();
-                    let e = rc(UnionLit(l.clone(), rc(a.clone()), kts.clone()));
-                    Continue(App(e, iter.map(ExprF::roll).collect()))
-                }
-                BoolIf(BoolLit(true), t, _) => DoneRef(t),
-                BoolIf(BoolLit(false), _, f) => DoneRef(f),
-                // TODO: interpolation
-                // TextLit(t) =>
-                OldOptionalLit(None, t) => Done(EmptyOptionalLit(t.roll())),
-                OldOptionalLit(Some(x), _) => Done(NEOptionalLit(x.roll())),
-                BinOp(BoolAnd, BoolLit(x), BoolLit(y)) => {
-                    Done(BoolLit(*x && *y))
-                }
-                BinOp(BoolOr, BoolLit(x), BoolLit(y)) => {
-                    Done(BoolLit(*x || *y))
-                }
-                BinOp(BoolEQ, BoolLit(x), BoolLit(y)) => Done(BoolLit(x == y)),
-                BinOp(BoolNE, BoolLit(x), BoolLit(y)) => Done(BoolLit(x != y)),
-                BinOp(NaturalPlus, NaturalLit(x), NaturalLit(y)) => {
-                    Done(NaturalLit(x + y))
-                }
-                BinOp(NaturalTimes, NaturalLit(x), NaturalLit(y)) => {
-                    Done(NaturalLit(x * y))
-                }
-                BinOp(TextAppend, TextLit(x), TextLit(y)) => {
-                    Done(TextLit(x + y))
-                }
-                BinOp(ListAppend, EmptyListLit(_), y) => DoneRef(y),
-                BinOp(ListAppend, x, EmptyListLit(_)) => DoneRef(x),
-                BinOp(ListAppend, NEListLit(xs), NEListLit(ys)) => {
-                    let xs = xs.iter().cloned();
-                    let ys = ys.iter().cloned();
-                    Done(NEListLit(xs.chain(ys).collect()))
-                }
-                Merge(RecordLit(handlers), UnionLit(l, v, _), _) => {
-                    match handlers.get(&l) {
-                        Some(h) => Continue(App(h.clone(), vec![v.clone()])),
-                        None => DoneAsIs,
-                    }
-                }
-                Merge(RecordLit(handlers), UnionConstructor(l, _), _) => {
-                    match handlers.get(&l) {
-                        Some(h) => DoneRefSub(h),
-                        None => DoneAsIs,
-                    }
-                }
-                Field(RecordLit(kvs), l) => match kvs.get(&l) {
-                    Some(r) => DoneRefSub(r),
-                    None => DoneAsIs,
-                },
-                Field(UnionType(kts), l) => {
-                    Done(UnionConstructor(l.clone(), kts.clone()))
-                }
-                Projection(_, ls) if ls.is_empty() => {
-                    Done(RecordLit(std::collections::BTreeMap::new()))
-                }
-                Projection(RecordLit(kvs), ls) => Done(RecordLit(
-                    ls.iter()
-                        .filter_map(|l| {
-                            kvs.get(l).map(|x| (l.clone(), x.clone()))
-                        })
-                        .collect(),
-                )),
-                _ => DoneAsIs,
-            };
+    // Recursively normalize all subexpressions
+    let expr: ExprF<Value, Label, X, Normalized<'static>> = e
+        .map_ref_with_special_handling_of_binders(
+            |e| normalize_value(ctx, e.clone()),
+            |x, e| normalize_value(&ctx.skip(x), e.clone()),
+            X::clone,
+            Normalized::clone,
+            Label::clone,
+        );
 
-            match what_next {
-                Continue(e) => normalize_value(ctx, e.embed_absurd().roll()),
-                Done(e) => e.roll(),
-                DoneRef(e) => e.roll(),
-                DoneSub(e) => e,
-                DoneRefSub(e) => e.clone(),
-                DoneAsIs => rc(expr.map_ref_simple(ExprF::roll).map_ref(
-                    SubExpr::clone,
-                    X::clone,
-                    |_| unreachable!(),
-                    Label::clone,
-                )),
+    let expr = match expr {
+        App(v, args) if args.is_empty() => return v,
+        App(Value::Lam(x, _, b), args) => {
+            let mut iter = args.into_iter();
+            // We know args is nonempty
+            let a = iter.next().unwrap();
+            // Beta reduce
+            let ctx2 = ctx.insert(&x, a.into_expr(ctx));
+            let b2 = normalize_value(&ctx2, b).into_expr(&ctx2);
+            return normalize_value(
+                ctx,
+                App(b2, iter.map(|val| val.into_expr(ctx)).collect())
+                    .embed_absurd()
+                    .roll(),
+            );
+        }
+        expr => expr,
+    };
+
+    let expr: ExprF<Expr<X, X>, Label, X, Normalized<'static>> = expr
+        .map_ref_with_special_handling_of_binders(
+            |e| e.clone().into_expr(ctx).unroll(),
+            |x, e| e.clone().into_expr(&ctx.skip(x)).unroll(),
+            X::clone,
+            Normalized::clone,
+            Label::clone,
+        );
+
+    use WhatNext::*;
+    let what_next = match &expr {
+        Embed(e) => DoneRefSub(&e.0),
+        Var(v) => DoneSub(ctx.lookup(v)),
+        Annot(x, _) => DoneRef(x),
+        Note(_, e) => DoneRef(e),
+        App(_, args) if args.is_empty() => unreachable!(),
+        Let(_, _, _, _) => unreachable!(),
+        Lam(_, _, _) => unreachable!(),
+        App(App(f, args1), args2) => Continue(App(
+            f.clone(),
+            args1
+                .iter()
+                .cloned()
+                .chain(args2.iter().map(ExprF::roll))
+                .collect(),
+        )),
+        App(Builtin(b), args) => apply_builtin(*b, args),
+        App(Lam(_, _, _), _) => unreachable!(),
+        App(UnionConstructor(l, kts), args) => {
+            let mut iter = args.iter();
+            // We know args is nonempty
+            let a = iter.next().unwrap();
+            let e = rc(UnionLit(l.clone(), rc(a.clone()), kts.clone()));
+            Continue(App(e, iter.map(ExprF::roll).collect()))
+        }
+        BoolIf(BoolLit(true), t, _) => DoneRef(t),
+        BoolIf(BoolLit(false), _, f) => DoneRef(f),
+        // TODO: interpolation
+        // TextLit(t) =>
+        OldOptionalLit(None, t) => Done(EmptyOptionalLit(t.roll())),
+        OldOptionalLit(Some(x), _) => Done(NEOptionalLit(x.roll())),
+        BinOp(BoolAnd, BoolLit(x), BoolLit(y)) => Done(BoolLit(*x && *y)),
+        BinOp(BoolOr, BoolLit(x), BoolLit(y)) => Done(BoolLit(*x || *y)),
+        BinOp(BoolEQ, BoolLit(x), BoolLit(y)) => Done(BoolLit(x == y)),
+        BinOp(BoolNE, BoolLit(x), BoolLit(y)) => Done(BoolLit(x != y)),
+        BinOp(NaturalPlus, NaturalLit(x), NaturalLit(y)) => {
+            Done(NaturalLit(x + y))
+        }
+        BinOp(NaturalTimes, NaturalLit(x), NaturalLit(y)) => {
+            Done(NaturalLit(x * y))
+        }
+        BinOp(TextAppend, TextLit(x), TextLit(y)) => Done(TextLit(x + y)),
+        BinOp(ListAppend, EmptyListLit(_), y) => DoneRef(y),
+        BinOp(ListAppend, x, EmptyListLit(_)) => DoneRef(x),
+        BinOp(ListAppend, NEListLit(xs), NEListLit(ys)) => {
+            let xs = xs.iter().cloned();
+            let ys = ys.iter().cloned();
+            Done(NEListLit(xs.chain(ys).collect()))
+        }
+        Merge(RecordLit(handlers), UnionLit(l, v, _), _) => {
+            match handlers.get(&l) {
+                Some(h) => Continue(App(h.clone(), vec![v.clone()])),
+                None => DoneAsIs,
+            }
+        }
+        Merge(RecordLit(handlers), UnionConstructor(l, _), _) => {
+            match handlers.get(&l) {
+                Some(h) => DoneRefSub(h),
+                None => DoneAsIs,
             }
         }
+        Field(RecordLit(kvs), l) => match kvs.get(&l) {
+            Some(r) => DoneRefSub(r),
+            None => DoneAsIs,
+        },
+        Field(UnionType(kts), l) => {
+            Done(UnionConstructor(l.clone(), kts.clone()))
+        }
+        Projection(_, ls) if ls.is_empty() => {
+            Done(RecordLit(std::collections::BTreeMap::new()))
+        }
+        Projection(RecordLit(kvs), ls) => Done(RecordLit(
+            ls.iter()
+                .filter_map(|l| kvs.get(l).map(|x| (l.clone(), x.clone())))
+                .collect(),
+        )),
+        _ => DoneAsIs,
+    };
+
+    match what_next {
+        Continue(e) => normalize_value(ctx, e.embed_absurd().roll()),
+        Done(e) => reval(e.roll()),
+        DoneRef(e) => reval(e.roll()),
+        DoneSub(e) => reval(e),
+        DoneRefSub(e) => reval(e.clone()),
+        DoneAsIs => reval(rc(expr.map_ref_simple(ExprF::roll).map_ref(
+            SubExpr::clone,
+            X::clone,
+            |_| unreachable!(),
+            Label::clone,
+        ))),
     }
 }
 
@@ -414,6 +470,7 @@ fn normalize_value(
 ///
 fn normalize(e: SubExpr<X, Normalized<'static>>) -> SubExpr<X, X> {
     normalize_value(&NormalizationContext::new(), e)
+        .into_expr(&NormalizationContext::new())
 }
 
 #[cfg(test)]
-- 
cgit v1.2.3


From 759705047eea74f538883c15b6abd3292bbebb13 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 19 Apr 2019 12:37:47 +0200
Subject: A partially applied builtin is a value

---
 dhall/src/normalize.rs | 69 ++++++++++++++++++++++++++++++--------------------
 1 file changed, 42 insertions(+), 27 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 90c6841..c053ca2 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -224,10 +224,7 @@ enum Value {
         SubExpr<X, Normalized<'static>>,
         SubExpr<X, Normalized<'static>>,
     ),
-    // App(
-    //     SubExpr<X, Normalized<'static>>,
-    //     Vec<SubExpr<X, Normalized<'static>>>,
-    // ),
+    AppliedBuiltin(Builtin, Vec<Value>),
 }
 
 impl Value {
@@ -239,12 +236,14 @@ impl Value {
                 normalize_value(ctx, t).into_expr(ctx),
                 normalize_value(&ctx.skip(&x), e).into_expr(&ctx.skip(&x)),
             )),
-            // Value::App(f, args) => rc(ExprF::App(
-            //     normalize_value(ctx, f).into_expr(ctx),
-            //     args.into_iter()
-            //         .map(|e| normalize_value(ctx, e).into_expr(ctx))
-            //         .collect(),
-            // )),
+            Value::AppliedBuiltin(b, args) if args.is_empty() => {
+                rc(ExprF::Builtin(b))
+            }
+            Value::AppliedBuiltin(b, args) => {
+                let args_rolled: Vec<_> =
+                    args.iter().map(|val| val.clone().into_expr(ctx)).collect();
+                rc(ExprF::App(rc(ExprF::Builtin(b)), args_rolled))
+            }
         }
     }
 }
@@ -301,11 +300,26 @@ enum WhatNext<'a, N, E> {
     DoneAsIs,
 }
 
+impl<'a> WhatNext<'a, X, X> {
+    fn into_value(self, ctx: &NormalizationContext) -> Option<Value> {
+        use WhatNext::*;
+        match self {
+            Continue(e) => Some(normalize_value(ctx, e.embed_absurd().roll())),
+            Done(e) => Some(reval(e.roll())),
+            DoneRef(e) => Some(reval(e.roll())),
+            DoneSub(e) => Some(reval(e)),
+            DoneRefSub(e) => Some(reval(e.clone())),
+            DoneAsIs => None,
+        }
+    }
+}
+
 fn reval(expr: SubExpr<X, X>) -> Value {
     match expr.as_ref() {
         ExprF::Lam(x, t, e) => {
             Value::Lam(x.clone(), t.embed_absurd(), e.embed_absurd())
         }
+        ExprF::Builtin(b) => Value::AppliedBuiltin(*b, vec![]),
         _ => Value::Expr(expr),
     }
 }
@@ -323,6 +337,7 @@ fn normalize_value(
             return normalize_value(&ctx.insert(x, r.clone()), b.clone());
         }
         Lam(x, t, e) => return Value::Lam(x.clone(), t.clone(), e.clone()),
+        ExprF::Builtin(b) => return Value::AppliedBuiltin(*b, vec![]),
         e => e,
     };
 
@@ -352,6 +367,18 @@ fn normalize_value(
                     .roll(),
             );
         }
+        App(Value::AppliedBuiltin(b, args1), args2) => {
+            let combined_args: Vec<_> =
+                args1.into_iter().chain(args2.into_iter()).collect();
+            let args_unrolled: Vec<_> = combined_args
+                .iter()
+                .map(|val| val.clone().into_expr(ctx).unroll())
+                .collect();
+            match apply_builtin(b, &args_unrolled).into_value(ctx) {
+                Some(v) => return v,
+                None => return Value::AppliedBuiltin(b, combined_args),
+            }
+        }
         expr => expr,
     };
 
@@ -370,18 +397,10 @@ fn normalize_value(
         Var(v) => DoneSub(ctx.lookup(v)),
         Annot(x, _) => DoneRef(x),
         Note(_, e) => DoneRef(e),
-        App(_, args) if args.is_empty() => unreachable!(),
         Let(_, _, _, _) => unreachable!(),
         Lam(_, _, _) => unreachable!(),
-        App(App(f, args1), args2) => Continue(App(
-            f.clone(),
-            args1
-                .iter()
-                .cloned()
-                .chain(args2.iter().map(ExprF::roll))
-                .collect(),
-        )),
-        App(Builtin(b), args) => apply_builtin(*b, args),
+        App(_, args) if args.is_empty() => unreachable!(),
+        App(Builtin(_), _) => unreachable!(),
         App(Lam(_, _, _), _) => unreachable!(),
         App(UnionConstructor(l, kts), args) => {
             let mut iter = args.iter();
@@ -444,13 +463,9 @@ fn normalize_value(
         _ => DoneAsIs,
     };
 
-    match what_next {
-        Continue(e) => normalize_value(ctx, e.embed_absurd().roll()),
-        Done(e) => reval(e.roll()),
-        DoneRef(e) => reval(e.roll()),
-        DoneSub(e) => reval(e),
-        DoneRefSub(e) => reval(e.clone()),
-        DoneAsIs => reval(rc(expr.map_ref_simple(ExprF::roll).map_ref(
+    match what_next.into_value(ctx) {
+        Some(e) => e,
+        None => reval(rc(expr.map_ref_simple(ExprF::roll).map_ref(
             SubExpr::clone,
             X::clone,
             |_| unreachable!(),
-- 
cgit v1.2.3


From 4bed7b11e227a3151a2ff9e74f9662c126aad5a4 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 19 Apr 2019 14:42:36 +0200
Subject: Make App() only store one argument

---
 dhall/src/binary.rs    |  12 ++---
 dhall/src/expr.rs      |   3 --
 dhall/src/normalize.rs | 116 ++++++++++++++++++++++---------------------------
 dhall/src/typecheck.rs |  64 ++++++++-------------------
 4 files changed, 76 insertions(+), 119 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/binary.rs b/dhall/src/binary.rs
index c12aa2a..62ebcf7 100644
--- a/dhall/src/binary.rs
+++ b/dhall/src/binary.rs
@@ -42,12 +42,12 @@ fn cbor_value_to_dhall(data: &cbor::Value) -> Result<ParsedExpr, DecodeError> {
                 Var(V(l, *n as usize))
             }
             [U64(0), f, args..] => {
-                let f = cbor_value_to_dhall(&f)?;
-                let args = args
-                    .iter()
-                    .map(cbor_value_to_dhall)
-                    .collect::<Result<Vec<_>, _>>()?;
-                App(f, args)
+                let mut f = cbor_value_to_dhall(&f)?;
+                for a in args {
+                    let a = cbor_value_to_dhall(&a)?;
+                    f = rc(App(f, a))
+                }
+                return Ok(f);
             }
             [U64(1), x, y] => {
                 let x = cbor_value_to_dhall(&x)?;
diff --git a/dhall/src/expr.rs b/dhall/src/expr.rs
index 5885359..bb1a4e4 100644
--- a/dhall/src/expr.rs
+++ b/dhall/src/expr.rs
@@ -107,9 +107,6 @@ impl<'a> Typed<'a> {
     pub(crate) fn as_expr(&self) -> &SubExpr<X, Normalized<'a>> {
         &self.0
     }
-    pub(crate) fn into_expr(self) -> SubExpr<X, Normalized<'a>> {
-        self.0
-    }
 }
 
 #[doc(hidden)]
diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index c053ca2..224650d 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -88,17 +88,17 @@ where
         }
         (ListBuild, [a0, g, rest..]) => {
             'ret: {
-                if let App(f2, args2) = g {
-                    if let (Builtin(ListFold), [_, x, rest_inner..]) =
-                        (f2.as_ref(), args2.as_slice())
-                    {
-                        // fold/build fusion
-                        break 'ret (
-                            rc(App(x.clone(), rest_inner.to_vec())),
-                            rest,
-                        );
-                    }
-                };
+                // if let App(f2, args2) = g {
+                //     if let (Builtin(ListFold), [_, x, rest_inner..]) =
+                //         (f2.as_ref(), args2.as_slice())
+                //     {
+                //         // fold/build fusion
+                //         break 'ret (
+                //             rc(App(x.clone(), rest_inner.to_vec())),
+                //             rest,
+                //         );
+                //     }
+                // };
                 let a0 = a0.roll();
                 let a1 = shift0(1, &"x".into(), &a0);
                 let g = g.roll();
@@ -115,17 +115,17 @@ where
         }
         (OptionalBuild, [a0, g, rest..]) => {
             'ret: {
-                if let App(f2, args2) = g {
-                    if let (Builtin(OptionalFold), [_, x, rest_inner..]) =
-                        (f2.as_ref(), args2.as_slice())
-                    {
-                        // fold/build fusion
-                        break 'ret (
-                            rc(App(x.clone(), rest_inner.to_vec())),
-                            rest,
-                        );
-                    }
-                };
+                // if let App(f2, args2) = g {
+                //     if let (Builtin(OptionalFold), [_, x, rest_inner..]) =
+                //         (f2.as_ref(), args2.as_slice())
+                //     {
+                //         // fold/build fusion
+                //         break 'ret (
+                //             rc(App(x.clone(), rest_inner.to_vec())),
+                //             rest,
+                //         );
+                //     }
+                // };
                 let a0 = a0.roll();
                 let g = g.roll();
                 break 'ret (
@@ -169,17 +169,17 @@ where
         // }
         (NaturalBuild, [g, rest..]) => {
             'ret: {
-                if let App(f2, args2) = g {
-                    if let (Builtin(NaturalFold), [x, rest_inner..]) =
-                        (f2.as_ref(), args2.as_slice())
-                    {
-                        // fold/build fusion
-                        break 'ret (
-                            rc(App(x.clone(), rest_inner.to_vec())),
-                            rest,
-                        );
-                    }
-                };
+                // if let App(f2, args2) = g {
+                //     if let (Builtin(NaturalFold), [x, rest_inner..]) =
+                //         (f2.as_ref(), args2.as_slice())
+                //     {
+                //         // fold/build fusion
+                //         break 'ret (
+                //             rc(App(x.clone(), rest_inner.to_vec())),
+                //             rest,
+                //         );
+                //     }
+                // };
                 let g = g.roll();
                 break 'ret (
                     dhall::subexpr!(g Natural (λ(x : Natural) -> x + 1) 0),
@@ -212,8 +212,8 @@ where
     // Put the remaining arguments back and eval again. In most cases
     // ret will not be of a form that can be applied, so this won't go very deep.
     // In lots of cases, there are no remaining args so this cann will just return ret.
-    let rest: Vec<SubExpr<N, E>> = rest.iter().map(ExprF::roll).collect();
-    Continue(ExprF::App(ret, rest))
+    let rest = rest.iter().map(ExprF::roll);
+    Continue(rest.fold(ret, |acc, e| rc(ExprF::App(acc, e))).unroll())
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -240,9 +240,11 @@ impl Value {
                 rc(ExprF::Builtin(b))
             }
             Value::AppliedBuiltin(b, args) => {
-                let args_rolled: Vec<_> =
-                    args.iter().map(|val| val.clone().into_expr(ctx)).collect();
-                rc(ExprF::App(rc(ExprF::Builtin(b)), args_rolled))
+                let args_rolled =
+                    args.iter().map(|val| val.clone().into_expr(ctx));
+                args_rolled.fold(rc(ExprF::Builtin(b)), |acc, e| {
+                    rc(ExprF::App(acc, e))
+                })
             }
         }
     }
@@ -352,24 +354,15 @@ fn normalize_value(
         );
 
     let expr = match expr {
-        App(v, args) if args.is_empty() => return v,
-        App(Value::Lam(x, _, b), args) => {
-            let mut iter = args.into_iter();
-            // We know args is nonempty
-            let a = iter.next().unwrap();
+        App(Value::Lam(x, _, b), a) => {
             // Beta reduce
             let ctx2 = ctx.insert(&x, a.into_expr(ctx));
-            let b2 = normalize_value(&ctx2, b).into_expr(&ctx2);
-            return normalize_value(
-                ctx,
-                App(b2, iter.map(|val| val.into_expr(ctx)).collect())
-                    .embed_absurd()
-                    .roll(),
-            );
-        }
-        App(Value::AppliedBuiltin(b, args1), args2) => {
+            // return normalize_value(&ctx2, b);
+            return reval(normalize_value(&ctx2, b).into_expr(&ctx2));
+        }
+        App(Value::AppliedBuiltin(b, args1), a) => {
             let combined_args: Vec<_> =
-                args1.into_iter().chain(args2.into_iter()).collect();
+                args1.into_iter().chain(std::iter::once(a)).collect();
             let args_unrolled: Vec<_> = combined_args
                 .iter()
                 .map(|val| val.clone().into_expr(ctx).unroll())
@@ -399,15 +392,10 @@ fn normalize_value(
         Note(_, e) => DoneRef(e),
         Let(_, _, _, _) => unreachable!(),
         Lam(_, _, _) => unreachable!(),
-        App(_, args) if args.is_empty() => unreachable!(),
         App(Builtin(_), _) => unreachable!(),
         App(Lam(_, _, _), _) => unreachable!(),
-        App(UnionConstructor(l, kts), args) => {
-            let mut iter = args.iter();
-            // We know args is nonempty
-            let a = iter.next().unwrap();
-            let e = rc(UnionLit(l.clone(), rc(a.clone()), kts.clone()));
-            Continue(App(e, iter.map(ExprF::roll).collect()))
+        App(UnionConstructor(l, kts), a) => {
+            Done(UnionLit(l.clone(), rc(a.clone()), kts.clone()))
         }
         BoolIf(BoolLit(true), t, _) => DoneRef(t),
         BoolIf(BoolLit(false), _, f) => DoneRef(f),
@@ -435,7 +423,7 @@ fn normalize_value(
         }
         Merge(RecordLit(handlers), UnionLit(l, v, _), _) => {
             match handlers.get(&l) {
-                Some(h) => Continue(App(h.clone(), vec![v.clone()])),
+                Some(h) => Continue(App(h.clone(), v.clone())),
                 None => DoneAsIs,
             }
         }
@@ -688,7 +676,7 @@ mod spec_tests {
     norm!(success_unit_LetWithType, "unit/LetWithType");
     norm!(success_unit_List, "unit/List");
     norm!(success_unit_ListBuild, "unit/ListBuild");
-    norm!(success_unit_ListBuildFoldFusion, "unit/ListBuildFoldFusion");
+    // norm!(success_unit_ListBuildFoldFusion, "unit/ListBuildFoldFusion");
     norm!(success_unit_ListBuildImplementation, "unit/ListBuildImplementation");
     norm!(success_unit_ListFold, "unit/ListFold");
     norm!(success_unit_ListFoldEmpty, "unit/ListFoldEmpty");
@@ -717,7 +705,7 @@ mod spec_tests {
     norm!(success_unit_MergeWithTypeNormalizeArguments, "unit/MergeWithTypeNormalizeArguments");
     norm!(success_unit_Natural, "unit/Natural");
     norm!(success_unit_NaturalBuild, "unit/NaturalBuild");
-    norm!(success_unit_NaturalBuildFoldFusion, "unit/NaturalBuildFoldFusion");
+    // norm!(success_unit_NaturalBuildFoldFusion, "unit/NaturalBuildFoldFusion");
     norm!(success_unit_NaturalBuildImplementation, "unit/NaturalBuildImplementation");
     norm!(success_unit_NaturalEven, "unit/NaturalEven");
     norm!(success_unit_NaturalEvenOne, "unit/NaturalEvenOne");
@@ -778,7 +766,7 @@ mod spec_tests {
     norm!(success_unit_OperatorTimesTwoAndTwo, "unit/OperatorTimesTwoAndTwo");
     norm!(success_unit_Optional, "unit/Optional");
     norm!(success_unit_OptionalBuild, "unit/OptionalBuild");
-    norm!(success_unit_OptionalBuildFoldFusion, "unit/OptionalBuildFoldFusion");
+    // norm!(success_unit_OptionalBuildFoldFusion, "unit/OptionalBuildFoldFusion");
     norm!(success_unit_OptionalBuildImplementation, "unit/OptionalBuildImplementation");
     norm!(success_unit_OptionalFold, "unit/OptionalFold");
     norm!(success_unit_OptionalFoldNone, "unit/OptionalFoldNone");
diff --git a/dhall/src/typecheck.rs b/dhall/src/typecheck.rs
index 65128cd..ddb96da 100644
--- a/dhall/src/typecheck.rs
+++ b/dhall/src/typecheck.rs
@@ -168,11 +168,7 @@ where
                     eq2
                 }
             }
-            (App(fL, aL), App(fR, aR)) => {
-                go(ctx, fL, fR)
-                    && aL.len() == aR.len()
-                    && aL.iter().zip(aR.iter()).all(|(aL, aR)| go(ctx, aL, aR))
-            }
+            (App(fL, aL), App(fR, aR)) => go(ctx, fL, fR) && go(ctx, aL, aR),
             (RecordType(ktsL0), RecordType(ktsR0)) => {
                 ktsL0.len() == ktsR0.len()
                     && ktsL0
@@ -474,46 +470,22 @@ fn type_last_layer(
             Some(e) => Ok(RetType(e.clone())),
             None => Err(mkerr(UnboundVariable)),
         },
-        App(f, args) => {
-            let mut tf = f.get_type()?.into_owned();
-            // Reconstruct the application `f a0 a1 ...`
-            // for error reporting
-            let mkf = |args: Vec<_>, i| {
-                rc(App(
-                    f.into_expr(),
-                    args.into_iter().take(i).map(Typed::into_expr).collect(),
-                ))
-            };
-
-            for (i, a) in args.iter().enumerate() {
-                let (x, tx, tb) = ensure_matches!(tf,
-                    Pi(x, tx, tb) => (x, tx, tb),
-                    mkerr(NotAFunction(Typed(
-                        mkf(args, i),
-                        Some(tf),
-                        PhantomData
-                    )))
-                );
-                let tx = mktype(ctx, tx.embed_absurd())?;
-                ensure_equal!(&tx, a.get_type()?, {
-                    let a = a.clone();
-                    mkerr(TypeMismatch(
-                        Typed(mkf(args, i + 1), Some(tf), PhantomData),
-                        tx.into_normalized()?,
-                        a,
-                    ))
-                });
-                tf = mktype(
-                    ctx,
-                    rc(Let(
-                        x.clone(),
-                        None,
-                        a.clone().normalize().embed(),
-                        tb.embed_absurd(),
-                    )),
-                )?;
-            }
-            Ok(RetType(tf))
+        App(f, a) => {
+            let tf = f.get_type()?;
+            let (x, tx, tb) = ensure_matches!(tf,
+                Pi(x, tx, tb) => (x, tx, tb),
+                mkerr(NotAFunction(f))
+            );
+            let tx = mktype(ctx, tx.embed_absurd())?;
+            ensure_equal!(a.get_type()?, &tx, {
+                mkerr(TypeMismatch(f, tx.into_normalized()?, a))
+            });
+            Ok(RetExpr(Let(
+                x.clone(),
+                None,
+                a.normalize().embed(),
+                tb.embed_absurd(),
+            )))
         }
         Annot(x, t) => {
             let t = t.normalize().into_type();
@@ -704,7 +676,7 @@ fn type_last_layer(
         TextLit(_) => Ok(RetType(simple_type_from_builtin(Text))),
         BinOp(o @ ListAppend, l, r) => {
             match l.get_type()?.unroll_ref()?.as_ref() {
-                App(f, args) if args.len() == 1 => match f.as_ref() {
+                App(f, _) => match f.as_ref() {
                     Builtin(List) => {}
                     _ => return Err(mkerr(BinOpTypeMismatch(o, l))),
                 },
-- 
cgit v1.2.3


From 6654a82341749495d18553260abb90e7fbefbdd9 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 19 Apr 2019 14:45:01 +0200
Subject: Type aliases

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

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 224650d..fc259d9 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -7,6 +7,9 @@ use dhall_generator as dhall;
 
 use crate::expr::*;
 
+type InputSubExpr = SubExpr<X, Normalized<'static>>;
+type OutputSubExpr = SubExpr<X, X>;
+
 impl<'a> Typed<'a> {
     pub fn normalize(self) -> Normalized<'a> {
         Normalized(normalize(self.0), self.1, self.2)
@@ -218,17 +221,17 @@ where
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 enum Value {
-    Expr(SubExpr<X, X>),
+    Expr(OutputSubExpr),
     Lam(
         Label,
-        SubExpr<X, Normalized<'static>>,
-        SubExpr<X, Normalized<'static>>,
+        InputSubExpr,
+        InputSubExpr,
     ),
     AppliedBuiltin(Builtin, Vec<Value>),
 }
 
 impl Value {
-    fn into_expr(self, ctx: &NormalizationContext) -> SubExpr<X, X> {
+    fn into_expr(self, ctx: &NormalizationContext) -> OutputSubExpr {
         match self {
             Value::Expr(e) => e,
             Value::Lam(x, t, e) => rc(ExprF::Lam(
@@ -252,7 +255,7 @@ impl Value {
 
 #[derive(Debug, Clone)]
 enum EnvItem {
-    Expr(SubExpr<X, X>),
+    Expr(OutputSubExpr),
     Skip(usize),
 }
 
@@ -262,7 +265,7 @@ impl NormalizationContext {
     fn new() -> NormalizationContext {
         NormalizationContext(Context::new())
     }
-    fn insert(&self, x: &Label, e: SubExpr<X, X>) -> NormalizationContext {
+    fn insert(&self, x: &Label, e: OutputSubExpr) -> NormalizationContext {
         NormalizationContext(self.0.insert(x.clone(), EnvItem::Expr(e)))
     }
     fn skip(&self, x: &Label) -> NormalizationContext {
@@ -279,7 +282,7 @@ impl NormalizationContext {
                 .insert(x.clone(), EnvItem::Skip(0)),
         )
     }
-    fn lookup(&self, var: &V<Label>) -> SubExpr<X, X> {
+    fn lookup(&self, var: &V<Label>) -> OutputSubExpr {
         let V(x, n) = var;
         match self.0.lookup(x, *n) {
             Some(EnvItem::Expr(e)) => e.clone(),
@@ -316,7 +319,7 @@ impl<'a> WhatNext<'a, X, X> {
     }
 }
 
-fn reval(expr: SubExpr<X, X>) -> Value {
+fn reval(expr: OutputSubExpr) -> Value {
     match expr.as_ref() {
         ExprF::Lam(x, t, e) => {
             Value::Lam(x.clone(), t.embed_absurd(), e.embed_absurd())
@@ -328,7 +331,7 @@ fn reval(expr: SubExpr<X, X>) -> Value {
 
 fn normalize_value(
     ctx: &NormalizationContext,
-    expr: SubExpr<X, Normalized<'static>>,
+    expr: InputSubExpr,
 ) -> Value {
     use dhall_core::BinOp::*;
     use dhall_core::ExprF::*;
@@ -471,7 +474,7 @@ fn normalize_value(
 /// However, `normalize` will not fail if the expression is ill-typed and will
 /// leave ill-typed sub-expressions unevaluated.
 ///
-fn normalize(e: SubExpr<X, Normalized<'static>>) -> SubExpr<X, X> {
+fn normalize(e: InputSubExpr) -> OutputSubExpr {
     normalize_value(&NormalizationContext::new(), e)
         .into_expr(&NormalizationContext::new())
 }
-- 
cgit v1.2.3


From 897a1da43bda583b570b0a8818945167fc0e2240 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 19 Apr 2019 19:02:17 +0200
Subject: Introduce closures

---
 dhall/src/normalize.rs | 182 ++++++++++++++++++++++++++++++++-----------------
 1 file changed, 120 insertions(+), 62 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index fc259d9..dd47e88 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -219,35 +219,89 @@ where
     Continue(rest.fold(ret, |acc, e| rc(ExprF::App(acc, e))).unroll())
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+// #[derive(Debug, Clone)]
+// struct ContextualizedSubExpr {
+//     ctx: NormalizationContext,
+//     expr: SubExpr<X, Normalized<'static>>,
+// }
+// impl ContextualizedSubExpr {
+//     fn normalize_value(self) -> Value {
+//         normalize_value(&self.ctx, self.expr)
+//     }
+//     fn normalize_expr(self) -> OutputSubExpr {
+//         normalize_value(&self.ctx, self.expr).into_expr(&self.ctx)
+//     }
+// }
+
+#[derive(Debug, Clone)]
 enum Value {
+    Closure(Closure),
     Expr(OutputSubExpr),
-    Lam(
-        Label,
-        InputSubExpr,
-        InputSubExpr,
-    ),
-    AppliedBuiltin(Builtin, Vec<Value>),
 }
 
 impl Value {
-    fn into_expr(self, ctx: &NormalizationContext) -> OutputSubExpr {
+    /// Convert the value back to a (normalized) syntactic expression
+    fn normalize_to_expr(self, _ctx: &NormalizationContext) -> OutputSubExpr {
         match self {
+            Value::Closure(c) => c.normalize_to_expr(),
             Value::Expr(e) => e,
-            Value::Lam(x, t, e) => rc(ExprF::Lam(
-                x.clone(),
-                normalize_value(ctx, t).into_expr(ctx),
-                normalize_value(&ctx.skip(&x), e).into_expr(&ctx.skip(&x)),
-            )),
-            Value::AppliedBuiltin(b, args) if args.is_empty() => {
-                rc(ExprF::Builtin(b))
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+enum Closure {
+    Lam(NormalizationContext, Label, InputSubExpr, InputSubExpr),
+    AppliedBuiltin(NormalizationContext, Builtin, Vec<Value>),
+}
+
+impl Closure {
+    /// Apply the closure to a value
+    fn app(self, val: Value) -> Value {
+        match self {
+            Closure::Lam(ctx, x, _, e) => {
+                let ctx2 = ctx.insert(&x, val.normalize_to_expr(&ctx));
+                normalize_value(&ctx2, e)
             }
-            Value::AppliedBuiltin(b, args) => {
-                let args_rolled =
-                    args.iter().map(|val| val.clone().into_expr(ctx));
-                args_rolled.fold(rc(ExprF::Builtin(b)), |acc, e| {
-                    rc(ExprF::App(acc, e))
-                })
+            Closure::AppliedBuiltin(ctx, b, mut args) => {
+                args.push(val);
+                let args_unrolled: Vec<_> = args
+                    .iter()
+                    .map(|val| val.clone().normalize_to_expr(&ctx).unroll())
+                    .collect();
+                match apply_builtin(b, &args_unrolled).into_value(&ctx) {
+                    Some(v) => return v,
+                    None => {
+                        return Value::Closure(Closure::AppliedBuiltin(
+                            ctx, b, args,
+                        ))
+                    }
+                }
+            }
+        }
+    }
+
+    /// Convert the closure back to a (normalized) syntactic expression
+    fn normalize_to_expr(self) -> OutputSubExpr {
+        match self {
+            Closure::Lam(ctx, x, t, e) => {
+                let ctx2 = ctx.skip(&x);
+                rc(ExprF::Lam(
+                    x.clone(),
+                    normalize_value(&ctx, t).normalize_to_expr(&ctx),
+                    normalize_value(&ctx2, e).normalize_to_expr(&ctx2),
+                ))
+            }
+            Closure::AppliedBuiltin(ctx, b, args) => {
+                if args.is_empty() {
+                    rc(ExprF::Builtin(b))
+                } else {
+                    args.into_iter()
+                        .map(|e| e.normalize_to_expr(&ctx))
+                        .fold(rc(ExprF::Builtin(b)), |acc, e| {
+                            rc(ExprF::App(acc, e))
+                        })
+                }
             }
         }
     }
@@ -259,6 +313,7 @@ enum EnvItem {
     Skip(usize),
 }
 
+#[derive(Debug, Clone)]
 struct NormalizationContext(Context<Label, EnvItem>);
 
 impl NormalizationContext {
@@ -310,39 +365,54 @@ impl<'a> WhatNext<'a, X, X> {
         use WhatNext::*;
         match self {
             Continue(e) => Some(normalize_value(ctx, e.embed_absurd().roll())),
-            Done(e) => Some(reval(e.roll())),
-            DoneRef(e) => Some(reval(e.roll())),
-            DoneSub(e) => Some(reval(e)),
-            DoneRefSub(e) => Some(reval(e.clone())),
+            Done(e) => Some(reval(ctx, e.roll())),
+            DoneRef(e) => Some(reval(ctx, e.roll())),
+            DoneSub(e) => Some(reval(ctx, e)),
+            DoneRefSub(e) => Some(reval(ctx, e.clone())),
             DoneAsIs => None,
         }
     }
 }
 
-fn reval(expr: OutputSubExpr) -> Value {
+fn reval(ctx: &NormalizationContext, expr: OutputSubExpr) -> Value {
     match expr.as_ref() {
-        ExprF::Lam(x, t, e) => {
-            Value::Lam(x.clone(), t.embed_absurd(), e.embed_absurd())
+        ExprF::Lam(x, t, e) => Value::Closure(Closure::Lam(
+            ctx.clone(),
+            x.clone(),
+            t.embed_absurd(),
+            e.embed_absurd(),
+        )),
+        ExprF::Builtin(b) => {
+            Value::Closure(Closure::AppliedBuiltin(ctx.clone(), *b, vec![]))
         }
-        ExprF::Builtin(b) => Value::AppliedBuiltin(*b, vec![]),
         _ => Value::Expr(expr),
     }
 }
 
-fn normalize_value(
-    ctx: &NormalizationContext,
-    expr: InputSubExpr,
-) -> Value {
+fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
     use dhall_core::BinOp::*;
     use dhall_core::ExprF::*;
 
     let e = match expr.as_ref() {
         Let(x, _, r, b) => {
-            let r = normalize_value(ctx, r.clone()).into_expr(ctx);
+            let r = normalize_value(ctx, r.clone()).normalize_to_expr(ctx);
             return normalize_value(&ctx.insert(x, r.clone()), b.clone());
         }
-        Lam(x, t, e) => return Value::Lam(x.clone(), t.clone(), e.clone()),
-        ExprF::Builtin(b) => return Value::AppliedBuiltin(*b, vec![]),
+        Lam(x, t, e) => {
+            return Value::Closure(Closure::Lam(
+                ctx.clone(),
+                x.clone(),
+                t.clone(),
+                e.clone(),
+            ))
+        }
+        ExprF::Builtin(b) => {
+            return Value::Closure(Closure::AppliedBuiltin(
+                ctx.clone(),
+                *b,
+                vec![],
+            ))
+        }
         e => e,
     };
 
@@ -357,31 +427,16 @@ fn normalize_value(
         );
 
     let expr = match expr {
-        App(Value::Lam(x, _, b), a) => {
-            // Beta reduce
-            let ctx2 = ctx.insert(&x, a.into_expr(ctx));
-            // return normalize_value(&ctx2, b);
-            return reval(normalize_value(&ctx2, b).into_expr(&ctx2));
-        }
-        App(Value::AppliedBuiltin(b, args1), a) => {
-            let combined_args: Vec<_> =
-                args1.into_iter().chain(std::iter::once(a)).collect();
-            let args_unrolled: Vec<_> = combined_args
-                .iter()
-                .map(|val| val.clone().into_expr(ctx).unroll())
-                .collect();
-            match apply_builtin(b, &args_unrolled).into_value(ctx) {
-                Some(v) => return v,
-                None => return Value::AppliedBuiltin(b, combined_args),
-            }
+        App(Value::Closure(c), a) => {
+            return c.app(a);
         }
         expr => expr,
     };
 
     let expr: ExprF<Expr<X, X>, Label, X, Normalized<'static>> = expr
         .map_ref_with_special_handling_of_binders(
-            |e| e.clone().into_expr(ctx).unroll(),
-            |x, e| e.clone().into_expr(&ctx.skip(x)).unroll(),
+            |e| e.clone().normalize_to_expr(ctx).unroll(),
+            |x, e| e.clone().normalize_to_expr(&ctx.skip(x)).unroll(),
             X::clone,
             Normalized::clone,
             Label::clone,
@@ -456,12 +511,15 @@ fn normalize_value(
 
     match what_next.into_value(ctx) {
         Some(e) => e,
-        None => reval(rc(expr.map_ref_simple(ExprF::roll).map_ref(
-            SubExpr::clone,
-            X::clone,
-            |_| unreachable!(),
-            Label::clone,
-        ))),
+        None => reval(
+            ctx,
+            rc(expr.map_ref_simple(ExprF::roll).map_ref(
+                SubExpr::clone,
+                X::clone,
+                |_| unreachable!(),
+                Label::clone,
+            )),
+        ),
     }
 }
 
@@ -476,7 +534,7 @@ fn normalize_value(
 ///
 fn normalize(e: InputSubExpr) -> OutputSubExpr {
     normalize_value(&NormalizationContext::new(), e)
-        .into_expr(&NormalizationContext::new())
+        .normalize_to_expr(&NormalizationContext::new())
 }
 
 #[cfg(test)]
-- 
cgit v1.2.3


From 12552383aa469b587b72b82337e5e17c6174ff9c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 19 Apr 2019 19:17:59 +0200
Subject: Store Values in the context

---
 dhall/src/normalize.rs | 46 ++++++++++++++++++++++++++++++++++++----------
 1 file changed, 36 insertions(+), 10 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index dd47e88..3242fb0 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -247,6 +247,13 @@ impl Value {
             Value::Expr(e) => e,
         }
     }
+
+    fn shift0(self, delta: isize, label: &Label) -> Self {
+        match self {
+            Value::Closure(c) => Value::Closure(c.shift0(delta, label)),
+            Value::Expr(e) => Value::Expr(shift0(delta, label, &e)),
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -260,7 +267,7 @@ impl Closure {
     fn app(self, val: Value) -> Value {
         match self {
             Closure::Lam(ctx, x, _, e) => {
-                let ctx2 = ctx.insert(&x, val.normalize_to_expr(&ctx));
+                let ctx2 = ctx.insert(&x, val);
                 normalize_value(&ctx2, e)
             }
             Closure::AppliedBuiltin(ctx, b, mut args) => {
@@ -305,11 +312,27 @@ impl Closure {
             }
         }
     }
+
+    fn shift0(self, delta: isize, label: &Label) -> Self {
+        match self {
+            Closure::Lam(ctx, x, t, e) => Closure::Lam(
+                ctx,
+                x,
+                shift0(delta, label, &t),
+                shift(delta, &V(label.clone(), 1), &e),
+            ),
+            Closure::AppliedBuiltin(ctx, b, args) => Closure::AppliedBuiltin(
+                ctx,
+                b,
+                args.into_iter().map(|e| e.shift0(delta, label)).collect(),
+            ),
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
 enum EnvItem {
-    Expr(OutputSubExpr),
+    Expr(Value),
     Skip(usize),
 }
 
@@ -320,7 +343,7 @@ impl NormalizationContext {
     fn new() -> NormalizationContext {
         NormalizationContext(Context::new())
     }
-    fn insert(&self, x: &Label, e: OutputSubExpr) -> NormalizationContext {
+    fn insert(&self, x: &Label, e: Value) -> NormalizationContext {
         NormalizationContext(self.0.insert(x.clone(), EnvItem::Expr(e)))
     }
     fn skip(&self, x: &Label) -> NormalizationContext {
@@ -329,7 +352,7 @@ impl NormalizationContext {
                 .map(|l, e| {
                     use EnvItem::*;
                     match e {
-                        Expr(e) => Expr(shift0(1, x, e)),
+                        Expr(e) => Expr(e.clone().shift0(1, x)),
                         Skip(n) if l == x => Skip(*n + 1),
                         Skip(n) => Skip(*n),
                     }
@@ -337,12 +360,14 @@ impl NormalizationContext {
                 .insert(x.clone(), EnvItem::Skip(0)),
         )
     }
-    fn lookup(&self, var: &V<Label>) -> OutputSubExpr {
+    fn lookup(&self, var: &V<Label>) -> Value {
         let V(x, n) = var;
         match self.0.lookup(x, *n) {
             Some(EnvItem::Expr(e)) => e.clone(),
-            Some(EnvItem::Skip(m)) => rc(ExprF::Var(V(x.clone(), *m))),
-            None => rc(ExprF::Var(V(x.clone(), *n))),
+            Some(EnvItem::Skip(m)) => {
+                Value::Expr(rc(ExprF::Var(V(x.clone(), *m))))
+            }
+            None => Value::Expr(rc(ExprF::Var(V(x.clone(), *n)))),
         }
     }
 }
@@ -395,8 +420,8 @@ fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
 
     let e = match expr.as_ref() {
         Let(x, _, r, b) => {
-            let r = normalize_value(ctx, r.clone()).normalize_to_expr(ctx);
-            return normalize_value(&ctx.insert(x, r.clone()), b.clone());
+            let r = normalize_value(ctx, r.clone());
+            return normalize_value(&ctx.insert(x, r), b.clone());
         }
         Lam(x, t, e) => {
             return Value::Closure(Closure::Lam(
@@ -427,6 +452,7 @@ fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
         );
 
     let expr = match expr {
+        Var(v) => return ctx.lookup(&v),
         App(Value::Closure(c), a) => {
             return c.app(a);
         }
@@ -445,9 +471,9 @@ fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
     use WhatNext::*;
     let what_next = match &expr {
         Embed(e) => DoneRefSub(&e.0),
-        Var(v) => DoneSub(ctx.lookup(v)),
         Annot(x, _) => DoneRef(x),
         Note(_, e) => DoneRef(e),
+        Var(_) => unreachable!(),
         Let(_, _, _, _) => unreachable!(),
         Lam(_, _, _) => unreachable!(),
         App(Builtin(_), _) => unreachable!(),
-- 
cgit v1.2.3


From ab93af7bb8bbe7785d76a86af531bae9b13574c4 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 19 Apr 2019 21:28:18 +0200
Subject: A union constructor is a purely semantic value

---
 dhall/src/normalize.rs | 155 +++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 123 insertions(+), 32 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 3242fb0..10732b9 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -1,4 +1,5 @@
 #![allow(non_snake_case)]
+use std::collections::BTreeMap;
 use std::fmt;
 
 use dhall_core::context::Context;
@@ -233,9 +234,15 @@ where
 //     }
 // }
 
+/// A semantic value. This is partially redundant with `dhall_core::Expr`, on purpose. `Expr` should
+/// be limited to syntactic expressions: either written by the user or meant to be printed.
+/// The rule is the following: we must _not_ construct values of type `Expr` while normalizing or
+/// typechecking, but only construct `Value`s.
 #[derive(Debug, Clone)]
 enum Value {
     Closure(Closure),
+    RecordLit(NormalizationContext, BTreeMap<Label, InputSubExpr>),
+    UnionType(NormalizationContext, BTreeMap<Label, Option<InputSubExpr>>),
     Expr(OutputSubExpr),
 }
 
@@ -244,6 +251,25 @@ impl Value {
     fn normalize_to_expr(self, _ctx: &NormalizationContext) -> OutputSubExpr {
         match self {
             Value::Closure(c) => c.normalize_to_expr(),
+            Value::RecordLit(ctx, kvs) => rc(ExprF::RecordLit(
+                kvs.into_iter()
+                    .map(|(k, v)| {
+                        (k, normalize_value(&ctx, v).normalize_to_expr(&ctx))
+                    })
+                    .collect(),
+            )),
+            Value::UnionType(ctx, kvs) => rc(ExprF::UnionType(
+                kvs.into_iter()
+                    .map(|(k, v)| {
+                        (
+                            k,
+                            v.map(|v| {
+                                normalize_value(&ctx, v).normalize_to_expr(&ctx)
+                            }),
+                        )
+                    })
+                    .collect(),
+            )),
             Value::Expr(e) => e,
         }
     }
@@ -252,6 +278,18 @@ impl Value {
         match self {
             Value::Closure(c) => Value::Closure(c.shift0(delta, label)),
             Value::Expr(e) => Value::Expr(shift0(delta, label, &e)),
+            Value::RecordLit(ctx, kvs) => Value::RecordLit(
+                ctx,
+                kvs.into_iter()
+                    .map(|(k, v)| (k, shift0(delta, label, &v)))
+                    .collect(),
+            ),
+            Value::UnionType(ctx, kvs) => Value::UnionType(
+                ctx,
+                kvs.into_iter()
+                    .map(|(k, v)| (k, v.map(|v| shift0(delta, label, &v))))
+                    .collect(),
+            ),
         }
     }
 }
@@ -260,6 +298,11 @@ impl Value {
 enum Closure {
     Lam(NormalizationContext, Label, InputSubExpr, InputSubExpr),
     AppliedBuiltin(NormalizationContext, Builtin, Vec<Value>),
+    UnionConstructor(
+        NormalizationContext,
+        Label,
+        BTreeMap<Label, Option<InputSubExpr>>,
+    ),
 }
 
 impl Closure {
@@ -277,14 +320,30 @@ impl Closure {
                     .map(|val| val.clone().normalize_to_expr(&ctx).unroll())
                     .collect();
                 match apply_builtin(b, &args_unrolled).into_value(&ctx) {
-                    Some(v) => return v,
+                    Some(v) => v,
                     None => {
-                        return Value::Closure(Closure::AppliedBuiltin(
-                            ctx, b, args,
-                        ))
+                        Value::Closure(Closure::AppliedBuiltin(ctx, b, args))
                     }
                 }
             }
+            Closure::UnionConstructor(ctx, l, kts) => {
+                let kts = kts
+                    .into_iter()
+                    .map(|(k, v)| {
+                        (
+                            k,
+                            v.map(|v| {
+                                normalize_value(&ctx, v).normalize_to_expr(&ctx)
+                            }),
+                        )
+                    })
+                    .collect();
+                Value::Expr(rc(ExprF::UnionLit(
+                    l,
+                    val.normalize_to_expr(&ctx),
+                    kts,
+                )))
+            }
         }
     }
 
@@ -310,6 +369,20 @@ impl Closure {
                         })
                 }
             }
+            Closure::UnionConstructor(ctx, l, kts) => {
+                let kts = kts
+                    .into_iter()
+                    .map(|(k, v)| {
+                        (
+                            k,
+                            v.map(|v| {
+                                normalize_value(&ctx, v).normalize_to_expr(&ctx)
+                            }),
+                        )
+                    })
+                    .collect();
+                rc(ExprF::Field(rc(ExprF::UnionType(kts)), l))
+            }
         }
     }
 
@@ -326,6 +399,13 @@ impl Closure {
                 b,
                 args.into_iter().map(|e| e.shift0(delta, label)).collect(),
             ),
+            Closure::UnionConstructor(ctx, l, kts) => {
+                let kts = kts
+                    .into_iter()
+                    .map(|(k, v)| (k, v.map(|v| shift0(delta, label, &v))))
+                    .collect();
+                Closure::UnionConstructor(ctx, l, kts)
+            }
         }
     }
 }
@@ -379,7 +459,6 @@ enum WhatNext<'a, N, E> {
     // The following expression is the normal form
     Done(Expr<N, E>),
     DoneRef(&'a Expr<N, E>),
-    DoneSub(SubExpr<N, E>),
     DoneRefSub(&'a SubExpr<N, E>),
     // The current expression is already in normal form
     DoneAsIs,
@@ -392,7 +471,6 @@ impl<'a> WhatNext<'a, X, X> {
             Continue(e) => Some(normalize_value(ctx, e.embed_absurd().roll())),
             Done(e) => Some(reval(ctx, e.roll())),
             DoneRef(e) => Some(reval(ctx, e.roll())),
-            DoneSub(e) => Some(reval(ctx, e)),
             DoneRefSub(e) => Some(reval(ctx, e.clone())),
             DoneAsIs => None,
         }
@@ -400,16 +478,15 @@ impl<'a> WhatNext<'a, X, X> {
 }
 
 fn reval(ctx: &NormalizationContext, expr: OutputSubExpr) -> Value {
-    match expr.as_ref() {
-        ExprF::Lam(x, t, e) => Value::Closure(Closure::Lam(
-            ctx.clone(),
-            x.clone(),
-            t.embed_absurd(),
-            e.embed_absurd(),
-        )),
+    match expr.as_ref().embed_absurd() {
+        ExprF::Lam(x, t, e) => {
+            Value::Closure(Closure::Lam(ctx.clone(), x, t, e))
+        }
         ExprF::Builtin(b) => {
-            Value::Closure(Closure::AppliedBuiltin(ctx.clone(), *b, vec![]))
+            Value::Closure(Closure::AppliedBuiltin(ctx.clone(), b, vec![]))
         }
+        ExprF::RecordLit(kvs) => Value::RecordLit(ctx.clone(), kvs),
+        ExprF::UnionType(kvs) => Value::UnionType(ctx.clone(), kvs),
         _ => Value::Expr(expr),
     }
 }
@@ -431,13 +508,19 @@ fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
                 e.clone(),
             ))
         }
-        ExprF::Builtin(b) => {
+        Builtin(b) => {
             return Value::Closure(Closure::AppliedBuiltin(
                 ctx.clone(),
                 *b,
                 vec![],
             ))
         }
+        ExprF::RecordLit(kvs) => {
+            return Value::RecordLit(ctx.clone(), kvs.clone())
+        }
+        ExprF::UnionType(kvs) => {
+            return Value::UnionType(ctx.clone(), kvs.clone())
+        }
         e => e,
     };
 
@@ -453,9 +536,28 @@ fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
 
     let expr = match expr {
         Var(v) => return ctx.lookup(&v),
-        App(Value::Closure(c), a) => {
-            return c.app(a);
-        }
+        Annot(x, _) => return x,
+        Note(_, e) => return e,
+        App(Value::Closure(c), a) => return c.app(a),
+        Field(Value::UnionType(ctx, kts), l) => {
+            return Value::Closure(Closure::UnionConstructor(ctx, l, kts))
+        }
+        Merge(
+            Value::RecordLit(record_ctx, mut handlers),
+            Value::Closure(Closure::UnionConstructor(ctor_ctx, l, kts)),
+            t,
+        ) => match handlers.remove(&l) {
+            Some(h) => return normalize_value(ctx, h),
+            None => {
+                return Value::Expr(rc(Merge(
+                    Value::RecordLit(record_ctx, handlers)
+                        .normalize_to_expr(ctx),
+                    Value::Closure(Closure::UnionConstructor(ctor_ctx, l, kts))
+                        .normalize_to_expr(ctx),
+                    t.map(|t| t.normalize_to_expr(ctx)),
+                )))
+            }
+        },
         expr => expr,
     };
 
@@ -471,16 +573,13 @@ fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
     use WhatNext::*;
     let what_next = match &expr {
         Embed(e) => DoneRefSub(&e.0),
-        Annot(x, _) => DoneRef(x),
-        Note(_, e) => DoneRef(e),
+        Annot(_, _) => unreachable!(),
+        Note(_, _) => unreachable!(),
         Var(_) => unreachable!(),
         Let(_, _, _, _) => unreachable!(),
         Lam(_, _, _) => unreachable!(),
         App(Builtin(_), _) => unreachable!(),
         App(Lam(_, _, _), _) => unreachable!(),
-        App(UnionConstructor(l, kts), a) => {
-            Done(UnionLit(l.clone(), rc(a.clone()), kts.clone()))
-        }
         BoolIf(BoolLit(true), t, _) => DoneRef(t),
         BoolIf(BoolLit(false), _, f) => DoneRef(f),
         // TODO: interpolation
@@ -511,19 +610,11 @@ fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
                 None => DoneAsIs,
             }
         }
-        Merge(RecordLit(handlers), UnionConstructor(l, _), _) => {
-            match handlers.get(&l) {
-                Some(h) => DoneRefSub(h),
-                None => DoneAsIs,
-            }
-        }
         Field(RecordLit(kvs), l) => match kvs.get(&l) {
             Some(r) => DoneRefSub(r),
             None => DoneAsIs,
         },
-        Field(UnionType(kts), l) => {
-            Done(UnionConstructor(l.clone(), kts.clone()))
-        }
+        Field(UnionType(_), _) => unreachable!(),
         Projection(_, ls) if ls.is_empty() => {
             Done(RecordLit(std::collections::BTreeMap::new()))
         }
-- 
cgit v1.2.3


From 975fce131c674010e3cddd90507f3552da9dd7f4 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 19 Apr 2019 21:34:42 +0200
Subject: Values carry their evaluation context

---
 dhall/src/normalize.rs | 48 ++++++++++++++++++++----------------------------
 1 file changed, 20 insertions(+), 28 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 10732b9..805ee4d 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -248,13 +248,13 @@ enum Value {
 
 impl Value {
     /// Convert the value back to a (normalized) syntactic expression
-    fn normalize_to_expr(self, _ctx: &NormalizationContext) -> OutputSubExpr {
+    fn normalize_to_expr(self) -> OutputSubExpr {
         match self {
             Value::Closure(c) => c.normalize_to_expr(),
             Value::RecordLit(ctx, kvs) => rc(ExprF::RecordLit(
                 kvs.into_iter()
                     .map(|(k, v)| {
-                        (k, normalize_value(&ctx, v).normalize_to_expr(&ctx))
+                        (k, normalize_value(&ctx, v).normalize_to_expr())
                     })
                     .collect(),
             )),
@@ -264,7 +264,7 @@ impl Value {
                         (
                             k,
                             v.map(|v| {
-                                normalize_value(&ctx, v).normalize_to_expr(&ctx)
+                                normalize_value(&ctx, v).normalize_to_expr()
                             }),
                         )
                     })
@@ -317,7 +317,7 @@ impl Closure {
                 args.push(val);
                 let args_unrolled: Vec<_> = args
                     .iter()
-                    .map(|val| val.clone().normalize_to_expr(&ctx).unroll())
+                    .map(|val| val.clone().normalize_to_expr().unroll())
                     .collect();
                 match apply_builtin(b, &args_unrolled).into_value(&ctx) {
                     Some(v) => v,
@@ -333,14 +333,14 @@ impl Closure {
                         (
                             k,
                             v.map(|v| {
-                                normalize_value(&ctx, v).normalize_to_expr(&ctx)
+                                normalize_value(&ctx, v).normalize_to_expr()
                             }),
                         )
                     })
                     .collect();
                 Value::Expr(rc(ExprF::UnionLit(
                     l,
-                    val.normalize_to_expr(&ctx),
+                    val.normalize_to_expr(),
                     kts,
                 )))
             }
@@ -354,16 +354,16 @@ impl Closure {
                 let ctx2 = ctx.skip(&x);
                 rc(ExprF::Lam(
                     x.clone(),
-                    normalize_value(&ctx, t).normalize_to_expr(&ctx),
-                    normalize_value(&ctx2, e).normalize_to_expr(&ctx2),
+                    normalize_value(&ctx, t).normalize_to_expr(),
+                    normalize_value(&ctx2, e).normalize_to_expr(),
                 ))
             }
-            Closure::AppliedBuiltin(ctx, b, args) => {
+            Closure::AppliedBuiltin(_ctx, b, args) => {
                 if args.is_empty() {
                     rc(ExprF::Builtin(b))
                 } else {
                     args.into_iter()
-                        .map(|e| e.normalize_to_expr(&ctx))
+                        .map(|e| e.normalize_to_expr())
                         .fold(rc(ExprF::Builtin(b)), |acc, e| {
                             rc(ExprF::App(acc, e))
                         })
@@ -376,7 +376,7 @@ impl Closure {
                         (
                             k,
                             v.map(|v| {
-                                normalize_value(&ctx, v).normalize_to_expr(&ctx)
+                                normalize_value(&ctx, v).normalize_to_expr()
                             }),
                         )
                     })
@@ -496,11 +496,11 @@ fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
     use dhall_core::ExprF::*;
 
     let e = match expr.as_ref() {
-        Let(x, _, r, b) => {
+        ExprF::Let(x, _, r, b) => {
             let r = normalize_value(ctx, r.clone());
             return normalize_value(&ctx.insert(x, r), b.clone());
         }
-        Lam(x, t, e) => {
+        ExprF::Lam(x, t, e) => {
             return Value::Closure(Closure::Lam(
                 ctx.clone(),
                 x.clone(),
@@ -508,7 +508,7 @@ fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
                 e.clone(),
             ))
         }
-        Builtin(b) => {
+        ExprF::Builtin(b) => {
             return Value::Closure(Closure::AppliedBuiltin(
                 ctx.clone(),
                 *b,
@@ -550,25 +550,18 @@ fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
             Some(h) => return normalize_value(ctx, h),
             None => {
                 return Value::Expr(rc(Merge(
-                    Value::RecordLit(record_ctx, handlers)
-                        .normalize_to_expr(ctx),
+                    Value::RecordLit(record_ctx, handlers).normalize_to_expr(),
                     Value::Closure(Closure::UnionConstructor(ctor_ctx, l, kts))
-                        .normalize_to_expr(ctx),
-                    t.map(|t| t.normalize_to_expr(ctx)),
+                        .normalize_to_expr(),
+                    t.map(|t| t.normalize_to_expr()),
                 )))
             }
         },
         expr => expr,
     };
 
-    let expr: ExprF<Expr<X, X>, Label, X, Normalized<'static>> = expr
-        .map_ref_with_special_handling_of_binders(
-            |e| e.clone().normalize_to_expr(ctx).unroll(),
-            |x, e| e.clone().normalize_to_expr(&ctx.skip(x)).unroll(),
-            X::clone,
-            Normalized::clone,
-            Label::clone,
-        );
+    let expr: ExprF<Expr<X, X>, Label, X, Normalized<'static>> =
+        expr.map_ref_simple(|e| e.clone().normalize_to_expr().unroll());
 
     use WhatNext::*;
     let what_next = match &expr {
@@ -650,8 +643,7 @@ fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
 /// leave ill-typed sub-expressions unevaluated.
 ///
 fn normalize(e: InputSubExpr) -> OutputSubExpr {
-    normalize_value(&NormalizationContext::new(), e)
-        .normalize_to_expr(&NormalizationContext::new())
+    normalize_value(&NormalizationContext::new(), e).normalize_to_expr()
 }
 
 #[cfg(test)]
-- 
cgit v1.2.3


From b127f516cde72cf3c090e8e01fe40c00d8e0ff9c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 19 Apr 2019 21:53:21 +0200
Subject: Split function in two phases

---
 dhall/src/normalize.rs | 36 ++++++++++++++++++++++++------------
 1 file changed, 24 insertions(+), 12 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 805ee4d..955ac4f 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -238,6 +238,12 @@ where
 /// be limited to syntactic expressions: either written by the user or meant to be printed.
 /// The rule is the following: we must _not_ construct values of type `Expr` while normalizing or
 /// typechecking, but only construct `Value`s.
+///
+/// Values usually store subexpressions unnormalized, to enable lazy normalization. They
+/// approximate Weak Head Normal-Form (WHNF). This means that the expression is normalized
+/// as little as possible, but just enough to know the first constructor of the
+/// normal form. This is identical to full normalization for simple types like integers,
+/// but for example for a record literal this means only knowing the field names.
 #[derive(Debug, Clone)]
 enum Value {
     Closure(Closure),
@@ -492,9 +498,6 @@ fn reval(ctx: &NormalizationContext, expr: OutputSubExpr) -> Value {
 }
 
 fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
-    use dhall_core::BinOp::*;
-    use dhall_core::ExprF::*;
-
     let e = match expr.as_ref() {
         ExprF::Let(x, _, r, b) => {
             let r = normalize_value(ctx, r.clone());
@@ -534,6 +537,18 @@ fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
             Label::clone,
         );
 
+    normalize_last_layer(ctx, expr)
+}
+
+/// When all sub-expressions have been (partially) normalized, eval the remaining toplevel layer.
+fn normalize_last_layer(
+    ctx: &NormalizationContext,
+    expr: ExprF<Value, Label, X, Normalized<'static>>,
+) -> Value {
+    use dhall_core::BinOp::*;
+    use dhall_core::ExprF::*;
+    use WhatNext::*;
+
     let expr = match expr {
         Var(v) => return ctx.lookup(&v),
         Annot(x, _) => return x,
@@ -548,14 +563,12 @@ fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
             t,
         ) => match handlers.remove(&l) {
             Some(h) => return normalize_value(ctx, h),
-            None => {
-                return Value::Expr(rc(Merge(
-                    Value::RecordLit(record_ctx, handlers).normalize_to_expr(),
-                    Value::Closure(Closure::UnionConstructor(ctor_ctx, l, kts))
-                        .normalize_to_expr(),
-                    t.map(|t| t.normalize_to_expr()),
-                )))
-            }
+            // Return ownership
+            None => Merge(
+                Value::RecordLit(record_ctx, handlers),
+                Value::Closure(Closure::UnionConstructor(ctor_ctx, l, kts)),
+                t,
+            ),
         },
         expr => expr,
     };
@@ -563,7 +576,6 @@ fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
     let expr: ExprF<Expr<X, X>, Label, X, Normalized<'static>> =
         expr.map_ref_simple(|e| e.clone().normalize_to_expr().unroll());
 
-    use WhatNext::*;
     let what_next = match &expr {
         Embed(e) => DoneRefSub(&e.0),
         Annot(_, _) => unreachable!(),
-- 
cgit v1.2.3


From 976647b1a887ee0753bf39dacd9528f62d9e086a Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 19 Apr 2019 22:22:58 +0200
Subject: Handle RecordLits fully semantically

---
 dhall/src/normalize.rs | 44 ++++++++++++++++++++++++++++----------------
 1 file changed, 28 insertions(+), 16 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 955ac4f..bd479d0 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -240,10 +240,10 @@ where
 /// typechecking, but only construct `Value`s.
 ///
 /// Values usually store subexpressions unnormalized, to enable lazy normalization. They
-/// approximate Weak Head Normal-Form (WHNF). This means that the expression is normalized
-/// as little as possible, but just enough to know the first constructor of the
-/// normal form. This is identical to full normalization for simple types like integers,
-/// but for example for a record literal this means only knowing the field names.
+/// approximate what's called Weak Head Normal-Form (WHNF). This means that the expression is
+/// normalized as little as possible, but just enough to know the first constructor of the normal
+/// form. This is identical to full normalization for simple types like integers, but for example
+/// for a record literal this means knowing just the field names.
 #[derive(Debug, Clone)]
 enum Value {
     Closure(Closure),
@@ -557,6 +557,27 @@ fn normalize_last_layer(
         Field(Value::UnionType(ctx, kts), l) => {
             return Value::Closure(Closure::UnionConstructor(ctx, l, kts))
         }
+        Field(Value::RecordLit(record_ctx, mut kvs), l) => match kvs.remove(&l)
+        {
+            Some(r) => return normalize_value(&record_ctx, r),
+            // Return ownership
+            None => Field(Value::RecordLit(record_ctx, kvs), l),
+        },
+        // Always simplify `x.{}` to `{}`
+        Projection(_, ls) if ls.is_empty() => {
+            return Value::RecordLit(
+                ctx.clone(),
+                std::collections::BTreeMap::new(),
+            )
+        }
+        Projection(Value::RecordLit(record_ctx, mut kvs), ls) => {
+            return Value::RecordLit(
+                record_ctx,
+                ls.into_iter()
+                    .filter_map(|l| kvs.remove(&l).map(|x| (l, x)))
+                    .collect(),
+            )
+        }
         Merge(
             Value::RecordLit(record_ctx, mut handlers),
             Value::Closure(Closure::UnionConstructor(ctor_ctx, l, kts)),
@@ -615,19 +636,10 @@ fn normalize_last_layer(
                 None => DoneAsIs,
             }
         }
-        Field(RecordLit(kvs), l) => match kvs.get(&l) {
-            Some(r) => DoneRefSub(r),
-            None => DoneAsIs,
-        },
+        Field(RecordLit(_), _) => unreachable!(),
         Field(UnionType(_), _) => unreachable!(),
-        Projection(_, ls) if ls.is_empty() => {
-            Done(RecordLit(std::collections::BTreeMap::new()))
-        }
-        Projection(RecordLit(kvs), ls) => Done(RecordLit(
-            ls.iter()
-                .filter_map(|l| kvs.get(l).map(|x| (l.clone(), x.clone())))
-                .collect(),
-        )),
+        Projection(_, ls) if ls.is_empty() => unreachable!(),
+        Projection(RecordLit(_), _) => unreachable!(),
         _ => DoneAsIs,
     };
 
-- 
cgit v1.2.3


From deeec70f6bd602f0f178766b8e89ec2585c279c0 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 19 Apr 2019 22:29:41 +0200
Subject: Embrace WHNF

---
 dhall/src/normalize.rs | 156 ++++++++++++++++++++++++-------------------------
 1 file changed, 77 insertions(+), 79 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index bd479d0..64c17c3 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -157,7 +157,7 @@ where
         ),
         // // fold/build fusion
         // (ListFold, [_, App(box Builtin(ListBuild), [_, x, rest..]), rest..]) => {
-        //     normalize_value(&App(bx(x.clone()), rest.to_vec()))
+        //     normalize_whnf(&App(bx(x.clone()), rest.to_vec()))
         // }
         (OptionalFold, [_, NEOptionalLit(x), _, just, _, rest..]) => {
             let x = x.clone();
@@ -169,7 +169,7 @@ where
         }
         // // fold/build fusion
         // (OptionalFold, [_, App(box Builtin(OptionalBuild), [_, x, rest..]), rest..]) => {
-        //     normalize_value(&App(bx(x.clone()), rest.to_vec()))
+        //     normalize_whnf(&App(bx(x.clone()), rest.to_vec()))
         // }
         (NaturalBuild, [g, rest..]) => {
             'ret: {
@@ -226,71 +226,71 @@ where
 //     expr: SubExpr<X, Normalized<'static>>,
 // }
 // impl ContextualizedSubExpr {
-//     fn normalize_value(self) -> Value {
-//         normalize_value(&self.ctx, self.expr)
+//     fn normalize_whnf(self) -> WHNF {
+//         normalize_whnf(&self.ctx, self.expr)
 //     }
 //     fn normalize_expr(self) -> OutputSubExpr {
-//         normalize_value(&self.ctx, self.expr).into_expr(&self.ctx)
+//         normalize_whnf(&self.ctx, self.expr).into_expr(&self.ctx)
 //     }
 // }
 
 /// A semantic value. This is partially redundant with `dhall_core::Expr`, on purpose. `Expr` should
 /// be limited to syntactic expressions: either written by the user or meant to be printed.
 /// The rule is the following: we must _not_ construct values of type `Expr` while normalizing or
-/// typechecking, but only construct `Value`s.
+/// typechecking, but only construct `WHNF`s.
 ///
-/// Values usually store subexpressions unnormalized, to enable lazy normalization. They
-/// approximate what's called Weak Head Normal-Form (WHNF). This means that the expression is
-/// normalized as little as possible, but just enough to know the first constructor of the normal
-/// form. This is identical to full normalization for simple types like integers, but for example
-/// for a record literal this means knowing just the field names.
+/// WHNFs usually store subexpressions unnormalized, to enable lazy normalization. They approximate
+/// what's called Weak Head Normal-Form (WHNF). This means that the expression is normalized as
+/// little as possible, but just enough to know the first constructor of the normal form. This is
+/// identical to full normalization for simple types like integers, but for e.g. a record literal
+/// this means knowing just the field names.
 #[derive(Debug, Clone)]
-enum Value {
+enum WHNF {
     Closure(Closure),
     RecordLit(NormalizationContext, BTreeMap<Label, InputSubExpr>),
     UnionType(NormalizationContext, BTreeMap<Label, Option<InputSubExpr>>),
     Expr(OutputSubExpr),
 }
 
-impl Value {
+impl WHNF {
     /// Convert the value back to a (normalized) syntactic expression
     fn normalize_to_expr(self) -> OutputSubExpr {
         match self {
-            Value::Closure(c) => c.normalize_to_expr(),
-            Value::RecordLit(ctx, kvs) => rc(ExprF::RecordLit(
+            WHNF::Closure(c) => c.normalize_to_expr(),
+            WHNF::RecordLit(ctx, kvs) => rc(ExprF::RecordLit(
                 kvs.into_iter()
                     .map(|(k, v)| {
-                        (k, normalize_value(&ctx, v).normalize_to_expr())
+                        (k, normalize_whnf(&ctx, v).normalize_to_expr())
                     })
                     .collect(),
             )),
-            Value::UnionType(ctx, kvs) => rc(ExprF::UnionType(
+            WHNF::UnionType(ctx, kvs) => rc(ExprF::UnionType(
                 kvs.into_iter()
                     .map(|(k, v)| {
                         (
                             k,
                             v.map(|v| {
-                                normalize_value(&ctx, v).normalize_to_expr()
+                                normalize_whnf(&ctx, v).normalize_to_expr()
                             }),
                         )
                     })
                     .collect(),
             )),
-            Value::Expr(e) => e,
+            WHNF::Expr(e) => e,
         }
     }
 
     fn shift0(self, delta: isize, label: &Label) -> Self {
         match self {
-            Value::Closure(c) => Value::Closure(c.shift0(delta, label)),
-            Value::Expr(e) => Value::Expr(shift0(delta, label, &e)),
-            Value::RecordLit(ctx, kvs) => Value::RecordLit(
+            WHNF::Closure(c) => WHNF::Closure(c.shift0(delta, label)),
+            WHNF::Expr(e) => WHNF::Expr(shift0(delta, label, &e)),
+            WHNF::RecordLit(ctx, kvs) => WHNF::RecordLit(
                 ctx,
                 kvs.into_iter()
                     .map(|(k, v)| (k, shift0(delta, label, &v)))
                     .collect(),
             ),
-            Value::UnionType(ctx, kvs) => Value::UnionType(
+            WHNF::UnionType(ctx, kvs) => WHNF::UnionType(
                 ctx,
                 kvs.into_iter()
                     .map(|(k, v)| (k, v.map(|v| shift0(delta, label, &v))))
@@ -303,7 +303,7 @@ impl Value {
 #[derive(Debug, Clone)]
 enum Closure {
     Lam(NormalizationContext, Label, InputSubExpr, InputSubExpr),
-    AppliedBuiltin(NormalizationContext, Builtin, Vec<Value>),
+    AppliedBuiltin(NormalizationContext, Builtin, Vec<WHNF>),
     UnionConstructor(
         NormalizationContext,
         Label,
@@ -313,11 +313,11 @@ enum Closure {
 
 impl Closure {
     /// Apply the closure to a value
-    fn app(self, val: Value) -> Value {
+    fn app(self, val: WHNF) -> WHNF {
         match self {
             Closure::Lam(ctx, x, _, e) => {
                 let ctx2 = ctx.insert(&x, val);
-                normalize_value(&ctx2, e)
+                normalize_whnf(&ctx2, e)
             }
             Closure::AppliedBuiltin(ctx, b, mut args) => {
                 args.push(val);
@@ -328,7 +328,7 @@ impl Closure {
                 match apply_builtin(b, &args_unrolled).into_value(&ctx) {
                     Some(v) => v,
                     None => {
-                        Value::Closure(Closure::AppliedBuiltin(ctx, b, args))
+                        WHNF::Closure(Closure::AppliedBuiltin(ctx, b, args))
                     }
                 }
             }
@@ -339,16 +339,12 @@ impl Closure {
                         (
                             k,
                             v.map(|v| {
-                                normalize_value(&ctx, v).normalize_to_expr()
+                                normalize_whnf(&ctx, v).normalize_to_expr()
                             }),
                         )
                     })
                     .collect();
-                Value::Expr(rc(ExprF::UnionLit(
-                    l,
-                    val.normalize_to_expr(),
-                    kts,
-                )))
+                WHNF::Expr(rc(ExprF::UnionLit(l, val.normalize_to_expr(), kts)))
             }
         }
     }
@@ -360,8 +356,8 @@ impl Closure {
                 let ctx2 = ctx.skip(&x);
                 rc(ExprF::Lam(
                     x.clone(),
-                    normalize_value(&ctx, t).normalize_to_expr(),
-                    normalize_value(&ctx2, e).normalize_to_expr(),
+                    normalize_whnf(&ctx, t).normalize_to_expr(),
+                    normalize_whnf(&ctx2, e).normalize_to_expr(),
                 ))
             }
             Closure::AppliedBuiltin(_ctx, b, args) => {
@@ -382,7 +378,7 @@ impl Closure {
                         (
                             k,
                             v.map(|v| {
-                                normalize_value(&ctx, v).normalize_to_expr()
+                                normalize_whnf(&ctx, v).normalize_to_expr()
                             }),
                         )
                     })
@@ -418,7 +414,7 @@ impl Closure {
 
 #[derive(Debug, Clone)]
 enum EnvItem {
-    Expr(Value),
+    Expr(WHNF),
     Skip(usize),
 }
 
@@ -429,7 +425,7 @@ impl NormalizationContext {
     fn new() -> NormalizationContext {
         NormalizationContext(Context::new())
     }
-    fn insert(&self, x: &Label, e: Value) -> NormalizationContext {
+    fn insert(&self, x: &Label, e: WHNF) -> NormalizationContext {
         NormalizationContext(self.0.insert(x.clone(), EnvItem::Expr(e)))
     }
     fn skip(&self, x: &Label) -> NormalizationContext {
@@ -446,14 +442,14 @@ impl NormalizationContext {
                 .insert(x.clone(), EnvItem::Skip(0)),
         )
     }
-    fn lookup(&self, var: &V<Label>) -> Value {
+    fn lookup(&self, var: &V<Label>) -> WHNF {
         let V(x, n) = var;
         match self.0.lookup(x, *n) {
             Some(EnvItem::Expr(e)) => e.clone(),
             Some(EnvItem::Skip(m)) => {
-                Value::Expr(rc(ExprF::Var(V(x.clone(), *m))))
+                WHNF::Expr(rc(ExprF::Var(V(x.clone(), *m))))
             }
-            None => Value::Expr(rc(ExprF::Var(V(x.clone(), *n)))),
+            None => WHNF::Expr(rc(ExprF::Var(V(x.clone(), *n)))),
         }
     }
 }
@@ -471,10 +467,10 @@ enum WhatNext<'a, N, E> {
 }
 
 impl<'a> WhatNext<'a, X, X> {
-    fn into_value(self, ctx: &NormalizationContext) -> Option<Value> {
+    fn into_value(self, ctx: &NormalizationContext) -> Option<WHNF> {
         use WhatNext::*;
         match self {
-            Continue(e) => Some(normalize_value(ctx, e.embed_absurd().roll())),
+            Continue(e) => Some(normalize_whnf(ctx, e.embed_absurd().roll())),
             Done(e) => Some(reval(ctx, e.roll())),
             DoneRef(e) => Some(reval(ctx, e.roll())),
             DoneRefSub(e) => Some(reval(ctx, e.clone())),
@@ -483,28 +479,29 @@ impl<'a> WhatNext<'a, X, X> {
     }
 }
 
-fn reval(ctx: &NormalizationContext, expr: OutputSubExpr) -> Value {
+fn reval(ctx: &NormalizationContext, expr: OutputSubExpr) -> WHNF {
     match expr.as_ref().embed_absurd() {
         ExprF::Lam(x, t, e) => {
-            Value::Closure(Closure::Lam(ctx.clone(), x, t, e))
+            WHNF::Closure(Closure::Lam(ctx.clone(), x, t, e))
         }
         ExprF::Builtin(b) => {
-            Value::Closure(Closure::AppliedBuiltin(ctx.clone(), b, vec![]))
+            WHNF::Closure(Closure::AppliedBuiltin(ctx.clone(), b, vec![]))
         }
-        ExprF::RecordLit(kvs) => Value::RecordLit(ctx.clone(), kvs),
-        ExprF::UnionType(kvs) => Value::UnionType(ctx.clone(), kvs),
-        _ => Value::Expr(expr),
+        ExprF::RecordLit(kvs) => WHNF::RecordLit(ctx.clone(), kvs),
+        ExprF::UnionType(kvs) => WHNF::UnionType(ctx.clone(), kvs),
+        _ => WHNF::Expr(expr),
     }
 }
 
-fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
+/// Reduces the imput expression to WHNF. See doc on `WHNF` for details.
+fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
     let e = match expr.as_ref() {
         ExprF::Let(x, _, r, b) => {
-            let r = normalize_value(ctx, r.clone());
-            return normalize_value(&ctx.insert(x, r), b.clone());
+            let r = normalize_whnf(ctx, r.clone());
+            return normalize_whnf(&ctx.insert(x, r), b.clone());
         }
         ExprF::Lam(x, t, e) => {
-            return Value::Closure(Closure::Lam(
+            return WHNF::Closure(Closure::Lam(
                 ctx.clone(),
                 x.clone(),
                 t.clone(),
@@ -512,26 +509,26 @@ fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
             ))
         }
         ExprF::Builtin(b) => {
-            return Value::Closure(Closure::AppliedBuiltin(
+            return WHNF::Closure(Closure::AppliedBuiltin(
                 ctx.clone(),
                 *b,
                 vec![],
             ))
         }
         ExprF::RecordLit(kvs) => {
-            return Value::RecordLit(ctx.clone(), kvs.clone())
+            return WHNF::RecordLit(ctx.clone(), kvs.clone())
         }
         ExprF::UnionType(kvs) => {
-            return Value::UnionType(ctx.clone(), kvs.clone())
+            return WHNF::UnionType(ctx.clone(), kvs.clone())
         }
         e => e,
     };
 
     // Recursively normalize all subexpressions
-    let expr: ExprF<Value, Label, X, Normalized<'static>> = e
+    let expr: ExprF<WHNF, Label, X, Normalized<'static>> = e
         .map_ref_with_special_handling_of_binders(
-            |e| normalize_value(ctx, e.clone()),
-            |x, e| normalize_value(&ctx.skip(x), e.clone()),
+            |e| normalize_whnf(ctx, e.clone()),
+            |x, e| normalize_whnf(&ctx.skip(x), e.clone()),
             X::clone,
             Normalized::clone,
             Label::clone,
@@ -543,8 +540,8 @@ fn normalize_value(ctx: &NormalizationContext, expr: InputSubExpr) -> Value {
 /// When all sub-expressions have been (partially) normalized, eval the remaining toplevel layer.
 fn normalize_last_layer(
     ctx: &NormalizationContext,
-    expr: ExprF<Value, Label, X, Normalized<'static>>,
-) -> Value {
+    expr: ExprF<WHNF, Label, X, Normalized<'static>>,
+) -> WHNF {
     use dhall_core::BinOp::*;
     use dhall_core::ExprF::*;
     use WhatNext::*;
@@ -553,25 +550,26 @@ fn normalize_last_layer(
         Var(v) => return ctx.lookup(&v),
         Annot(x, _) => return x,
         Note(_, e) => return e,
-        App(Value::Closure(c), a) => return c.app(a),
-        Field(Value::UnionType(ctx, kts), l) => {
-            return Value::Closure(Closure::UnionConstructor(ctx, l, kts))
+        App(WHNF::Closure(c), a) => return c.app(a),
+        Field(WHNF::UnionType(ctx, kts), l) => {
+            return WHNF::Closure(Closure::UnionConstructor(ctx, l, kts))
+        }
+        Field(WHNF::RecordLit(record_ctx, mut kvs), l) => {
+            match kvs.remove(&l) {
+                Some(r) => return normalize_whnf(&record_ctx, r),
+                // Return ownership
+                None => Field(WHNF::RecordLit(record_ctx, kvs), l),
+            }
         }
-        Field(Value::RecordLit(record_ctx, mut kvs), l) => match kvs.remove(&l)
-        {
-            Some(r) => return normalize_value(&record_ctx, r),
-            // Return ownership
-            None => Field(Value::RecordLit(record_ctx, kvs), l),
-        },
         // Always simplify `x.{}` to `{}`
         Projection(_, ls) if ls.is_empty() => {
-            return Value::RecordLit(
+            return WHNF::RecordLit(
                 ctx.clone(),
                 std::collections::BTreeMap::new(),
             )
         }
-        Projection(Value::RecordLit(record_ctx, mut kvs), ls) => {
-            return Value::RecordLit(
+        Projection(WHNF::RecordLit(record_ctx, mut kvs), ls) => {
+            return WHNF::RecordLit(
                 record_ctx,
                 ls.into_iter()
                     .filter_map(|l| kvs.remove(&l).map(|x| (l, x)))
@@ -579,15 +577,15 @@ fn normalize_last_layer(
             )
         }
         Merge(
-            Value::RecordLit(record_ctx, mut handlers),
-            Value::Closure(Closure::UnionConstructor(ctor_ctx, l, kts)),
+            WHNF::RecordLit(record_ctx, mut handlers),
+            WHNF::Closure(Closure::UnionConstructor(ctor_ctx, l, kts)),
             t,
         ) => match handlers.remove(&l) {
-            Some(h) => return normalize_value(ctx, h),
+            Some(h) => return normalize_whnf(ctx, h),
             // Return ownership
             None => Merge(
-                Value::RecordLit(record_ctx, handlers),
-                Value::Closure(Closure::UnionConstructor(ctor_ctx, l, kts)),
+                WHNF::RecordLit(record_ctx, handlers),
+                WHNF::Closure(Closure::UnionConstructor(ctor_ctx, l, kts)),
                 t,
             ),
         },
@@ -667,7 +665,7 @@ fn normalize_last_layer(
 /// leave ill-typed sub-expressions unevaluated.
 ///
 fn normalize(e: InputSubExpr) -> OutputSubExpr {
-    normalize_value(&NormalizationContext::new(), e).normalize_to_expr()
+    normalize_whnf(&NormalizationContext::new(), e).normalize_to_expr()
 }
 
 #[cfg(test)]
-- 
cgit v1.2.3


From 2f837c22016e156fbc39e02c2f48ba7507c35d16 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 19 Apr 2019 23:15:34 +0200
Subject: List literals

---
 dhall/src/normalize.rs | 54 +++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 47 insertions(+), 7 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 64c17c3..1529784 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -247,6 +247,8 @@ where
 #[derive(Debug, Clone)]
 enum WHNF {
     Closure(Closure),
+    EmptyListLit(NormalizationContext, InputSubExpr),
+    NEListLit(Vec<(NormalizationContext, Vec<InputSubExpr>)>),
     RecordLit(NormalizationContext, BTreeMap<Label, InputSubExpr>),
     UnionType(NormalizationContext, BTreeMap<Label, Option<InputSubExpr>>),
     Expr(OutputSubExpr),
@@ -257,6 +259,18 @@ impl WHNF {
     fn normalize_to_expr(self) -> OutputSubExpr {
         match self {
             WHNF::Closure(c) => c.normalize_to_expr(),
+            WHNF::EmptyListLit(ctx, e) => rc(ExprF::EmptyListLit(
+                normalize_whnf(&ctx, e).normalize_to_expr(),
+            )),
+            WHNF::NEListLit(elts) => rc(ExprF::NEListLit(
+                elts.into_iter()
+                    .flat_map(|(ctx, vs)| {
+                        vs.into_iter().map(move |v| {
+                            normalize_whnf(&ctx, v).normalize_to_expr()
+                        })
+                    })
+                    .collect(),
+            )),
             WHNF::RecordLit(ctx, kvs) => rc(ExprF::RecordLit(
                 kvs.into_iter()
                     .map(|(k, v)| {
@@ -284,6 +298,21 @@ impl WHNF {
         match self {
             WHNF::Closure(c) => WHNF::Closure(c.shift0(delta, label)),
             WHNF::Expr(e) => WHNF::Expr(shift0(delta, label, &e)),
+            WHNF::EmptyListLit(ctx, e) => {
+                WHNF::EmptyListLit(ctx, shift0(delta, label, &e))
+            }
+            WHNF::NEListLit(elts) => WHNF::NEListLit(
+                elts.into_iter()
+                    .map(|(ctx, vs)| {
+                        (
+                            ctx,
+                            vs.into_iter()
+                                .map(|v| shift0(delta, label, &v))
+                                .collect(),
+                        )
+                    })
+                    .collect(),
+            ),
             WHNF::RecordLit(ctx, kvs) => WHNF::RecordLit(
                 ctx,
                 kvs.into_iter()
@@ -487,6 +516,8 @@ fn reval(ctx: &NormalizationContext, expr: OutputSubExpr) -> WHNF {
         ExprF::Builtin(b) => {
             WHNF::Closure(Closure::AppliedBuiltin(ctx.clone(), b, vec![]))
         }
+        ExprF::EmptyListLit(e) => WHNF::EmptyListLit(ctx.clone(), e),
+        ExprF::NEListLit(elts) => WHNF::NEListLit(vec![(ctx.clone(), elts)]),
         ExprF::RecordLit(kvs) => WHNF::RecordLit(ctx.clone(), kvs),
         ExprF::UnionType(kvs) => WHNF::UnionType(ctx.clone(), kvs),
         _ => WHNF::Expr(expr),
@@ -515,6 +546,12 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
                 vec![],
             ))
         }
+        ExprF::EmptyListLit(e) => {
+            return WHNF::EmptyListLit(ctx.clone(), e.clone())
+        }
+        ExprF::NEListLit(elts) => {
+            return WHNF::NEListLit(vec![(ctx.clone(), elts.clone())])
+        }
         ExprF::RecordLit(kvs) => {
             return WHNF::RecordLit(ctx.clone(), kvs.clone())
         }
@@ -551,6 +588,13 @@ fn normalize_last_layer(
         Annot(x, _) => return x,
         Note(_, e) => return e,
         App(WHNF::Closure(c), a) => return c.app(a),
+        BinOp(ListAppend, WHNF::EmptyListLit(_, _), y) => return y,
+        BinOp(ListAppend, x, WHNF::EmptyListLit(_, _)) => return x,
+        BinOp(ListAppend, WHNF::NEListLit(xs), WHNF::NEListLit(ys)) => {
+            let xs = xs.into_iter();
+            let ys = ys.into_iter();
+            return WHNF::NEListLit(xs.chain(ys).collect());
+        }
         Field(WHNF::UnionType(ctx, kts), l) => {
             return WHNF::Closure(Closure::UnionConstructor(ctx, l, kts))
         }
@@ -621,13 +665,9 @@ fn normalize_last_layer(
             Done(NaturalLit(x * y))
         }
         BinOp(TextAppend, TextLit(x), TextLit(y)) => Done(TextLit(x + y)),
-        BinOp(ListAppend, EmptyListLit(_), y) => DoneRef(y),
-        BinOp(ListAppend, x, EmptyListLit(_)) => DoneRef(x),
-        BinOp(ListAppend, NEListLit(xs), NEListLit(ys)) => {
-            let xs = xs.iter().cloned();
-            let ys = ys.iter().cloned();
-            Done(NEListLit(xs.chain(ys).collect()))
-        }
+        BinOp(ListAppend, EmptyListLit(_), _) => unreachable!(),
+        BinOp(ListAppend, _, EmptyListLit(_)) => unreachable!(),
+        BinOp(ListAppend, NEListLit(_), NEListLit(_)) => unreachable!(),
         Merge(RecordLit(handlers), UnionLit(l, v, _), _) => {
             match handlers.get(&l) {
                 Some(h) => Continue(App(h.clone(), v.clone())),
-- 
cgit v1.2.3


From 4ae764a65cdca472ba67fce9f54b0f9de7510a1c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 19 Apr 2019 23:24:16 +0200
Subject: Boolean literals

---
 dhall/src/normalize.rs | 44 ++++++++++++++++++++++++++++++++++----------
 1 file changed, 34 insertions(+), 10 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 1529784..53d7f86 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -247,6 +247,7 @@ where
 #[derive(Debug, Clone)]
 enum WHNF {
     Closure(Closure),
+    BoolLit(bool),
     EmptyListLit(NormalizationContext, InputSubExpr),
     NEListLit(Vec<(NormalizationContext, Vec<InputSubExpr>)>),
     RecordLit(NormalizationContext, BTreeMap<Label, InputSubExpr>),
@@ -259,6 +260,7 @@ impl WHNF {
     fn normalize_to_expr(self) -> OutputSubExpr {
         match self {
             WHNF::Closure(c) => c.normalize_to_expr(),
+            WHNF::BoolLit(b) => rc(ExprF::BoolLit(b)),
             WHNF::EmptyListLit(ctx, e) => rc(ExprF::EmptyListLit(
                 normalize_whnf(&ctx, e).normalize_to_expr(),
             )),
@@ -298,6 +300,7 @@ impl WHNF {
         match self {
             WHNF::Closure(c) => WHNF::Closure(c.shift0(delta, label)),
             WHNF::Expr(e) => WHNF::Expr(shift0(delta, label, &e)),
+            WHNF::BoolLit(b) => WHNF::BoolLit(b),
             WHNF::EmptyListLit(ctx, e) => {
                 WHNF::EmptyListLit(ctx, shift0(delta, label, &e))
             }
@@ -516,6 +519,7 @@ fn reval(ctx: &NormalizationContext, expr: OutputSubExpr) -> WHNF {
         ExprF::Builtin(b) => {
             WHNF::Closure(Closure::AppliedBuiltin(ctx.clone(), b, vec![]))
         }
+        ExprF::BoolLit(b) => WHNF::BoolLit(b),
         ExprF::EmptyListLit(e) => WHNF::EmptyListLit(ctx.clone(), e),
         ExprF::NEListLit(elts) => WHNF::NEListLit(vec![(ctx.clone(), elts)]),
         ExprF::RecordLit(kvs) => WHNF::RecordLit(ctx.clone(), kvs),
@@ -526,7 +530,7 @@ fn reval(ctx: &NormalizationContext, expr: OutputSubExpr) -> WHNF {
 
 /// Reduces the imput expression to WHNF. See doc on `WHNF` for details.
 fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
-    let e = match expr.as_ref() {
+    let expr = match expr.as_ref() {
         ExprF::Let(x, _, r, b) => {
             let r = normalize_whnf(ctx, r.clone());
             return normalize_whnf(&ctx.insert(x, r), b.clone());
@@ -546,6 +550,7 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
                 vec![],
             ))
         }
+        ExprF::BoolLit(b) => return WHNF::BoolLit(*b),
         ExprF::EmptyListLit(e) => {
             return WHNF::EmptyListLit(ctx.clone(), e.clone())
         }
@@ -558,12 +563,20 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
         ExprF::UnionType(kvs) => {
             return WHNF::UnionType(ctx.clone(), kvs.clone())
         }
-        e => e,
+        ExprF::BoolIf(b, e1, e2) => {
+            let b = normalize_whnf(ctx, b.clone());
+            match b {
+                WHNF::BoolLit(true) => return normalize_whnf(ctx, e1.clone()),
+                WHNF::BoolLit(false) => return normalize_whnf(ctx, e2.clone()),
+                _ => expr,
+            }
+        }
+        _ => expr,
     };
 
     // Recursively normalize all subexpressions
-    let expr: ExprF<WHNF, Label, X, Normalized<'static>> = e
-        .map_ref_with_special_handling_of_binders(
+    let expr: ExprF<WHNF, Label, X, Normalized<'static>> =
+        expr.as_ref().map_ref_with_special_handling_of_binders(
             |e| normalize_whnf(ctx, e.clone()),
             |x, e| normalize_whnf(&ctx.skip(x), e.clone()),
             X::clone,
@@ -588,6 +601,18 @@ fn normalize_last_layer(
         Annot(x, _) => return x,
         Note(_, e) => return e,
         App(WHNF::Closure(c), a) => return c.app(a),
+        BinOp(BoolAnd, WHNF::BoolLit(x), WHNF::BoolLit(y)) => {
+            return WHNF::BoolLit(x && y)
+        }
+        BinOp(BoolOr, WHNF::BoolLit(x), WHNF::BoolLit(y)) => {
+            return WHNF::BoolLit(x || y)
+        }
+        BinOp(BoolEQ, WHNF::BoolLit(x), WHNF::BoolLit(y)) => {
+            return WHNF::BoolLit(x == y)
+        }
+        BinOp(BoolNE, WHNF::BoolLit(x), WHNF::BoolLit(y)) => {
+            return WHNF::BoolLit(x != y)
+        }
         BinOp(ListAppend, WHNF::EmptyListLit(_, _), y) => return y,
         BinOp(ListAppend, x, WHNF::EmptyListLit(_, _)) => return x,
         BinOp(ListAppend, WHNF::NEListLit(xs), WHNF::NEListLit(ys)) => {
@@ -648,16 +673,15 @@ fn normalize_last_layer(
         Lam(_, _, _) => unreachable!(),
         App(Builtin(_), _) => unreachable!(),
         App(Lam(_, _, _), _) => unreachable!(),
-        BoolIf(BoolLit(true), t, _) => DoneRef(t),
-        BoolIf(BoolLit(false), _, f) => DoneRef(f),
+        BoolIf(BoolLit(_), _, _) => unreachable!(),
         // TODO: interpolation
         // TextLit(t) =>
         OldOptionalLit(None, t) => Done(EmptyOptionalLit(t.roll())),
         OldOptionalLit(Some(x), _) => Done(NEOptionalLit(x.roll())),
-        BinOp(BoolAnd, BoolLit(x), BoolLit(y)) => Done(BoolLit(*x && *y)),
-        BinOp(BoolOr, BoolLit(x), BoolLit(y)) => Done(BoolLit(*x || *y)),
-        BinOp(BoolEQ, BoolLit(x), BoolLit(y)) => Done(BoolLit(x == y)),
-        BinOp(BoolNE, BoolLit(x), BoolLit(y)) => Done(BoolLit(x != y)),
+        BinOp(BoolAnd, BoolLit(_), BoolLit(_)) => unreachable!(),
+        BinOp(BoolOr, BoolLit(_), BoolLit(_)) => unreachable!(),
+        BinOp(BoolEQ, BoolLit(_), BoolLit(_)) => unreachable!(),
+        BinOp(BoolNE, BoolLit(_), BoolLit(_)) => unreachable!(),
         BinOp(NaturalPlus, NaturalLit(x), NaturalLit(y)) => {
             Done(NaturalLit(x + y))
         }
-- 
cgit v1.2.3


From 110b8fb66c01f013e8b748b4e41645ab1c949639 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 19 Apr 2019 23:31:39 +0200
Subject: Implement boolean simplifications

---
 dhall/src/normalize.rs | 55 ++++++++++++++++++++++++++++----------------------
 1 file changed, 31 insertions(+), 24 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 53d7f86..5c9cf5d 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -492,7 +492,6 @@ enum WhatNext<'a, N, E> {
     Continue(Expr<N, E>),
     // The following expression is the normal form
     Done(Expr<N, E>),
-    DoneRef(&'a Expr<N, E>),
     DoneRefSub(&'a SubExpr<N, E>),
     // The current expression is already in normal form
     DoneAsIs,
@@ -504,7 +503,6 @@ impl<'a> WhatNext<'a, X, X> {
         match self {
             Continue(e) => Some(normalize_whnf(ctx, e.embed_absurd().roll())),
             Done(e) => Some(reval(ctx, e.roll())),
-            DoneRef(e) => Some(reval(ctx, e.roll())),
             DoneRefSub(e) => Some(reval(ctx, e.clone())),
             DoneAsIs => None,
         }
@@ -601,18 +599,26 @@ fn normalize_last_layer(
         Annot(x, _) => return x,
         Note(_, e) => return e,
         App(WHNF::Closure(c), a) => return c.app(a),
-        BinOp(BoolAnd, WHNF::BoolLit(x), WHNF::BoolLit(y)) => {
-            return WHNF::BoolLit(x && y)
-        }
-        BinOp(BoolOr, WHNF::BoolLit(x), WHNF::BoolLit(y)) => {
-            return WHNF::BoolLit(x || y)
-        }
+
+        BinOp(BoolAnd, WHNF::BoolLit(true), y) => return y,
+        BinOp(BoolAnd, x, WHNF::BoolLit(true)) => return x,
+        BinOp(BoolAnd, WHNF::BoolLit(false), _) => return WHNF::BoolLit(false),
+        BinOp(BoolAnd, _, WHNF::BoolLit(false)) => return WHNF::BoolLit(false),
+        BinOp(BoolOr, WHNF::BoolLit(true), _) => return WHNF::BoolLit(true),
+        BinOp(BoolOr, _, WHNF::BoolLit(true)) => return WHNF::BoolLit(true),
+        BinOp(BoolOr, WHNF::BoolLit(false), y) => return y,
+        BinOp(BoolOr, x, WHNF::BoolLit(false)) => return x,
+        BinOp(BoolEQ, WHNF::BoolLit(true), y) => return y,
+        BinOp(BoolEQ, x, WHNF::BoolLit(true)) => return x,
+        BinOp(BoolNE, WHNF::BoolLit(false), y) => return y,
+        BinOp(BoolNE, x, WHNF::BoolLit(false)) => return x,
         BinOp(BoolEQ, WHNF::BoolLit(x), WHNF::BoolLit(y)) => {
             return WHNF::BoolLit(x == y)
         }
         BinOp(BoolNE, WHNF::BoolLit(x), WHNF::BoolLit(y)) => {
             return WHNF::BoolLit(x != y)
         }
+
         BinOp(ListAppend, WHNF::EmptyListLit(_, _), y) => return y,
         BinOp(ListAppend, x, WHNF::EmptyListLit(_, _)) => return x,
         BinOp(ListAppend, WHNF::NEListLit(xs), WHNF::NEListLit(ys)) => {
@@ -620,6 +626,7 @@ fn normalize_last_layer(
             let ys = ys.into_iter();
             return WHNF::NEListLit(xs.chain(ys).collect());
         }
+
         Field(WHNF::UnionType(ctx, kts), l) => {
             return WHNF::Closure(Closure::UnionConstructor(ctx, l, kts))
         }
@@ -983,29 +990,29 @@ mod spec_tests {
     norm!(success_unit_None, "unit/None");
     norm!(success_unit_NoneNatural, "unit/NoneNatural");
     // norm!(success_unit_OperatorAndEquivalentArguments, "unit/OperatorAndEquivalentArguments");
-    // norm!(success_unit_OperatorAndLhsFalse, "unit/OperatorAndLhsFalse");
-    // norm!(success_unit_OperatorAndLhsTrue, "unit/OperatorAndLhsTrue");
-    // norm!(success_unit_OperatorAndNormalizeArguments, "unit/OperatorAndNormalizeArguments");
-    // norm!(success_unit_OperatorAndRhsFalse, "unit/OperatorAndRhsFalse");
-    // norm!(success_unit_OperatorAndRhsTrue, "unit/OperatorAndRhsTrue");
+    norm!(success_unit_OperatorAndLhsFalse, "unit/OperatorAndLhsFalse");
+    norm!(success_unit_OperatorAndLhsTrue, "unit/OperatorAndLhsTrue");
+    norm!(success_unit_OperatorAndNormalizeArguments, "unit/OperatorAndNormalizeArguments");
+    norm!(success_unit_OperatorAndRhsFalse, "unit/OperatorAndRhsFalse");
+    norm!(success_unit_OperatorAndRhsTrue, "unit/OperatorAndRhsTrue");
     // norm!(success_unit_OperatorEqualEquivalentArguments, "unit/OperatorEqualEquivalentArguments");
-    // norm!(success_unit_OperatorEqualLhsTrue, "unit/OperatorEqualLhsTrue");
-    // norm!(success_unit_OperatorEqualNormalizeArguments, "unit/OperatorEqualNormalizeArguments");
-    // norm!(success_unit_OperatorEqualRhsTrue, "unit/OperatorEqualRhsTrue");
+    norm!(success_unit_OperatorEqualLhsTrue, "unit/OperatorEqualLhsTrue");
+    norm!(success_unit_OperatorEqualNormalizeArguments, "unit/OperatorEqualNormalizeArguments");
+    norm!(success_unit_OperatorEqualRhsTrue, "unit/OperatorEqualRhsTrue");
     norm!(success_unit_OperatorListConcatenateLhsEmpty, "unit/OperatorListConcatenateLhsEmpty");
     norm!(success_unit_OperatorListConcatenateListList, "unit/OperatorListConcatenateListList");
     norm!(success_unit_OperatorListConcatenateNormalizeArguments, "unit/OperatorListConcatenateNormalizeArguments");
     norm!(success_unit_OperatorListConcatenateRhsEmpty, "unit/OperatorListConcatenateRhsEmpty");
     // norm!(success_unit_OperatorNotEqualEquivalentArguments, "unit/OperatorNotEqualEquivalentArguments");
-    // norm!(success_unit_OperatorNotEqualLhsFalse, "unit/OperatorNotEqualLhsFalse");
-    // norm!(success_unit_OperatorNotEqualNormalizeArguments, "unit/OperatorNotEqualNormalizeArguments");
-    // norm!(success_unit_OperatorNotEqualRhsFalse, "unit/OperatorNotEqualRhsFalse");
+    norm!(success_unit_OperatorNotEqualLhsFalse, "unit/OperatorNotEqualLhsFalse");
+    norm!(success_unit_OperatorNotEqualNormalizeArguments, "unit/OperatorNotEqualNormalizeArguments");
+    norm!(success_unit_OperatorNotEqualRhsFalse, "unit/OperatorNotEqualRhsFalse");
     // norm!(success_unit_OperatorOrEquivalentArguments, "unit/OperatorOrEquivalentArguments");
-    // norm!(success_unit_OperatorOrLhsFalse, "unit/OperatorOrLhsFalse");
-    // norm!(success_unit_OperatorOrLhsTrue, "unit/OperatorOrLhsTrue");
-    // norm!(success_unit_OperatorOrNormalizeArguments, "unit/OperatorOrNormalizeArguments");
-    // norm!(success_unit_OperatorOrRhsFalse, "unit/OperatorOrRhsFalse");
-    // norm!(success_unit_OperatorOrRhsTrue, "unit/OperatorOrRhsTrue");
+    norm!(success_unit_OperatorOrLhsFalse, "unit/OperatorOrLhsFalse");
+    norm!(success_unit_OperatorOrLhsTrue, "unit/OperatorOrLhsTrue");
+    norm!(success_unit_OperatorOrNormalizeArguments, "unit/OperatorOrNormalizeArguments");
+    norm!(success_unit_OperatorOrRhsFalse, "unit/OperatorOrRhsFalse");
+    norm!(success_unit_OperatorOrRhsTrue, "unit/OperatorOrRhsTrue");
     // norm!(success_unit_OperatorPlusLhsZero, "unit/OperatorPlusLhsZero");
     // norm!(success_unit_OperatorPlusNormalizeArguments, "unit/OperatorPlusNormalizeArguments");
     norm!(success_unit_OperatorPlusOneAndOne, "unit/OperatorPlusOneAndOne");
-- 
cgit v1.2.3


From 8fbd51228e392e8a6e6281e3f136f4e07760c41f Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 19 Apr 2019 23:37:09 +0200
Subject: Natural literals and simplifications

---
 dhall/src/normalize.rs | 46 ++++++++++++++++++++++++++++++++--------------
 1 file changed, 32 insertions(+), 14 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 5c9cf5d..5766766 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -248,6 +248,7 @@ where
 enum WHNF {
     Closure(Closure),
     BoolLit(bool),
+    NaturalLit(Natural),
     EmptyListLit(NormalizationContext, InputSubExpr),
     NEListLit(Vec<(NormalizationContext, Vec<InputSubExpr>)>),
     RecordLit(NormalizationContext, BTreeMap<Label, InputSubExpr>),
@@ -261,6 +262,7 @@ impl WHNF {
         match self {
             WHNF::Closure(c) => c.normalize_to_expr(),
             WHNF::BoolLit(b) => rc(ExprF::BoolLit(b)),
+            WHNF::NaturalLit(n) => rc(ExprF::NaturalLit(n)),
             WHNF::EmptyListLit(ctx, e) => rc(ExprF::EmptyListLit(
                 normalize_whnf(&ctx, e).normalize_to_expr(),
             )),
@@ -301,6 +303,7 @@ impl WHNF {
             WHNF::Closure(c) => WHNF::Closure(c.shift0(delta, label)),
             WHNF::Expr(e) => WHNF::Expr(shift0(delta, label, &e)),
             WHNF::BoolLit(b) => WHNF::BoolLit(b),
+            WHNF::NaturalLit(n) => WHNF::NaturalLit(n),
             WHNF::EmptyListLit(ctx, e) => {
                 WHNF::EmptyListLit(ctx, shift0(delta, label, &e))
             }
@@ -518,6 +521,7 @@ fn reval(ctx: &NormalizationContext, expr: OutputSubExpr) -> WHNF {
             WHNF::Closure(Closure::AppliedBuiltin(ctx.clone(), b, vec![]))
         }
         ExprF::BoolLit(b) => WHNF::BoolLit(b),
+        ExprF::NaturalLit(n) => WHNF::NaturalLit(n),
         ExprF::EmptyListLit(e) => WHNF::EmptyListLit(ctx.clone(), e),
         ExprF::NEListLit(elts) => WHNF::NEListLit(vec![(ctx.clone(), elts)]),
         ExprF::RecordLit(kvs) => WHNF::RecordLit(ctx.clone(), kvs),
@@ -549,6 +553,7 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
             ))
         }
         ExprF::BoolLit(b) => return WHNF::BoolLit(*b),
+        ExprF::NaturalLit(n) => return WHNF::NaturalLit(*n),
         ExprF::EmptyListLit(e) => {
             return WHNF::EmptyListLit(ctx.clone(), e.clone())
         }
@@ -619,6 +624,23 @@ fn normalize_last_layer(
             return WHNF::BoolLit(x != y)
         }
 
+        BinOp(NaturalPlus, WHNF::NaturalLit(0), y) => return y,
+        BinOp(NaturalPlus, x, WHNF::NaturalLit(0)) => return x,
+        BinOp(NaturalTimes, WHNF::NaturalLit(0), _) => {
+            return WHNF::NaturalLit(0)
+        }
+        BinOp(NaturalTimes, _, WHNF::NaturalLit(0)) => {
+            return WHNF::NaturalLit(0)
+        }
+        BinOp(NaturalTimes, WHNF::NaturalLit(1), y) => return y,
+        BinOp(NaturalTimes, x, WHNF::NaturalLit(1)) => return x,
+        BinOp(NaturalPlus, WHNF::NaturalLit(x), WHNF::NaturalLit(y)) => {
+            return WHNF::NaturalLit(x + y)
+        }
+        BinOp(NaturalTimes, WHNF::NaturalLit(x), WHNF::NaturalLit(y)) => {
+            return WHNF::NaturalLit(x * y)
+        }
+
         BinOp(ListAppend, WHNF::EmptyListLit(_, _), y) => return y,
         BinOp(ListAppend, x, WHNF::EmptyListLit(_, _)) => return x,
         BinOp(ListAppend, WHNF::NEListLit(xs), WHNF::NEListLit(ys)) => {
@@ -689,12 +711,8 @@ fn normalize_last_layer(
         BinOp(BoolOr, BoolLit(_), BoolLit(_)) => unreachable!(),
         BinOp(BoolEQ, BoolLit(_), BoolLit(_)) => unreachable!(),
         BinOp(BoolNE, BoolLit(_), BoolLit(_)) => unreachable!(),
-        BinOp(NaturalPlus, NaturalLit(x), NaturalLit(y)) => {
-            Done(NaturalLit(x + y))
-        }
-        BinOp(NaturalTimes, NaturalLit(x), NaturalLit(y)) => {
-            Done(NaturalLit(x * y))
-        }
+        BinOp(NaturalPlus, NaturalLit(_), NaturalLit(_)) => unreachable!(),
+        BinOp(NaturalTimes, NaturalLit(_), NaturalLit(_)) => unreachable!(),
         BinOp(TextAppend, TextLit(x), TextLit(y)) => Done(TextLit(x + y)),
         BinOp(ListAppend, EmptyListLit(_), _) => unreachable!(),
         BinOp(ListAppend, _, EmptyListLit(_)) => unreachable!(),
@@ -1013,19 +1031,19 @@ mod spec_tests {
     norm!(success_unit_OperatorOrNormalizeArguments, "unit/OperatorOrNormalizeArguments");
     norm!(success_unit_OperatorOrRhsFalse, "unit/OperatorOrRhsFalse");
     norm!(success_unit_OperatorOrRhsTrue, "unit/OperatorOrRhsTrue");
-    // norm!(success_unit_OperatorPlusLhsZero, "unit/OperatorPlusLhsZero");
-    // norm!(success_unit_OperatorPlusNormalizeArguments, "unit/OperatorPlusNormalizeArguments");
+    norm!(success_unit_OperatorPlusLhsZero, "unit/OperatorPlusLhsZero");
+    norm!(success_unit_OperatorPlusNormalizeArguments, "unit/OperatorPlusNormalizeArguments");
     norm!(success_unit_OperatorPlusOneAndOne, "unit/OperatorPlusOneAndOne");
-    // norm!(success_unit_OperatorPlusRhsZero, "unit/OperatorPlusRhsZero");
+    norm!(success_unit_OperatorPlusRhsZero, "unit/OperatorPlusRhsZero");
     // norm!(success_unit_OperatorTextConcatenateLhsEmpty, "unit/OperatorTextConcatenateLhsEmpty");
     // norm!(success_unit_OperatorTextConcatenateNormalizeArguments, "unit/OperatorTextConcatenateNormalizeArguments");
     // norm!(success_unit_OperatorTextConcatenateRhsEmpty, "unit/OperatorTextConcatenateRhsEmpty");
     norm!(success_unit_OperatorTextConcatenateTextText, "unit/OperatorTextConcatenateTextText");
-    // norm!(success_unit_OperatorTimesLhsOne, "unit/OperatorTimesLhsOne");
-    // norm!(success_unit_OperatorTimesLhsZero, "unit/OperatorTimesLhsZero");
-    // norm!(success_unit_OperatorTimesNormalizeArguments, "unit/OperatorTimesNormalizeArguments");
-    // norm!(success_unit_OperatorTimesRhsOne, "unit/OperatorTimesRhsOne");
-    // norm!(success_unit_OperatorTimesRhsZero, "unit/OperatorTimesRhsZero");
+    norm!(success_unit_OperatorTimesLhsOne, "unit/OperatorTimesLhsOne");
+    norm!(success_unit_OperatorTimesLhsZero, "unit/OperatorTimesLhsZero");
+    norm!(success_unit_OperatorTimesNormalizeArguments, "unit/OperatorTimesNormalizeArguments");
+    norm!(success_unit_OperatorTimesRhsOne, "unit/OperatorTimesRhsOne");
+    norm!(success_unit_OperatorTimesRhsZero, "unit/OperatorTimesRhsZero");
     norm!(success_unit_OperatorTimesTwoAndTwo, "unit/OperatorTimesTwoAndTwo");
     norm!(success_unit_Optional, "unit/Optional");
     norm!(success_unit_OptionalBuild, "unit/OptionalBuild");
-- 
cgit v1.2.3


From 2f411181e4abe05bf9ad9015654348fa8e13495e Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 00:20:41 +0200
Subject: Optionals and unions

---
 dhall/src/normalize.rs | 120 +++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 96 insertions(+), 24 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 5766766..d02dd80 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -244,15 +244,26 @@ where
 /// little as possible, but just enough to know the first constructor of the normal form. This is
 /// identical to full normalization for simple types like integers, but for e.g. a record literal
 /// this means knowing just the field names.
+///
+/// Each variant captures the relevant contexts when it is constructed. Conceptually each
+/// subexpression has its own context, but in practise contexts can be shared when sensible, to
+/// avoid unnecessary allocations.
 #[derive(Debug, Clone)]
 enum WHNF {
     Closure(Closure),
     BoolLit(bool),
     NaturalLit(Natural),
+    EmptyOptionalLit(NormalizationContext, InputSubExpr),
+    NEOptionalLit(NormalizationContext, InputSubExpr),
     EmptyListLit(NormalizationContext, InputSubExpr),
     NEListLit(Vec<(NormalizationContext, Vec<InputSubExpr>)>),
     RecordLit(NormalizationContext, BTreeMap<Label, InputSubExpr>),
     UnionType(NormalizationContext, BTreeMap<Label, Option<InputSubExpr>>),
+    UnionLit(
+        Label,
+        Box<WHNF>,
+        (NormalizationContext, BTreeMap<Label, Option<InputSubExpr>>),
+    ),
     Expr(OutputSubExpr),
 }
 
@@ -263,6 +274,12 @@ impl WHNF {
             WHNF::Closure(c) => c.normalize_to_expr(),
             WHNF::BoolLit(b) => rc(ExprF::BoolLit(b)),
             WHNF::NaturalLit(n) => rc(ExprF::NaturalLit(n)),
+            WHNF::EmptyOptionalLit(ctx, e) => rc(ExprF::EmptyOptionalLit(
+                normalize_whnf(&ctx, e).normalize_to_expr(),
+            )),
+            WHNF::NEOptionalLit(ctx, e) => rc(ExprF::NEOptionalLit(
+                normalize_whnf(&ctx, e).normalize_to_expr(),
+            )),
             WHNF::EmptyListLit(ctx, e) => rc(ExprF::EmptyListLit(
                 normalize_whnf(&ctx, e).normalize_to_expr(),
             )),
@@ -282,8 +299,8 @@ impl WHNF {
                     })
                     .collect(),
             )),
-            WHNF::UnionType(ctx, kvs) => rc(ExprF::UnionType(
-                kvs.into_iter()
+            WHNF::UnionType(ctx, kts) => rc(ExprF::UnionType(
+                kts.into_iter()
                     .map(|(k, v)| {
                         (
                             k,
@@ -294,6 +311,20 @@ impl WHNF {
                     })
                     .collect(),
             )),
+            WHNF::UnionLit(l, v, (kts_ctx, kts)) => rc(ExprF::UnionLit(
+                l,
+                v.normalize_to_expr(),
+                kts.into_iter()
+                    .map(|(k, v)| {
+                        (
+                            k,
+                            v.map(|v| {
+                                normalize_whnf(&kts_ctx, v).normalize_to_expr()
+                            }),
+                        )
+                    })
+                    .collect(),
+            )),
             WHNF::Expr(e) => e,
         }
     }
@@ -304,6 +335,12 @@ impl WHNF {
             WHNF::Expr(e) => WHNF::Expr(shift0(delta, label, &e)),
             WHNF::BoolLit(b) => WHNF::BoolLit(b),
             WHNF::NaturalLit(n) => WHNF::NaturalLit(n),
+            WHNF::EmptyOptionalLit(ctx, e) => {
+                WHNF::EmptyOptionalLit(ctx, shift0(delta, label, &e))
+            }
+            WHNF::NEOptionalLit(ctx, e) => {
+                WHNF::NEOptionalLit(ctx, shift0(delta, label, &e))
+            }
             WHNF::EmptyListLit(ctx, e) => {
                 WHNF::EmptyListLit(ctx, shift0(delta, label, &e))
             }
@@ -325,12 +362,22 @@ impl WHNF {
                     .map(|(k, v)| (k, shift0(delta, label, &v)))
                     .collect(),
             ),
-            WHNF::UnionType(ctx, kvs) => WHNF::UnionType(
+            WHNF::UnionType(ctx, kts) => WHNF::UnionType(
                 ctx,
-                kvs.into_iter()
+                kts.into_iter()
                     .map(|(k, v)| (k, v.map(|v| shift0(delta, label, &v))))
                     .collect(),
             ),
+            WHNF::UnionLit(l, v, (kts_ctx, kts)) => WHNF::UnionLit(
+                l,
+                Box::new(v.shift0(delta, label)),
+                (
+                    kts_ctx,
+                    kts.into_iter()
+                        .map(|(k, v)| (k, v.map(|v| shift0(delta, label, &v))))
+                        .collect(),
+                ),
+            ),
         }
     }
 }
@@ -368,18 +415,7 @@ impl Closure {
                 }
             }
             Closure::UnionConstructor(ctx, l, kts) => {
-                let kts = kts
-                    .into_iter()
-                    .map(|(k, v)| {
-                        (
-                            k,
-                            v.map(|v| {
-                                normalize_whnf(&ctx, v).normalize_to_expr()
-                            }),
-                        )
-                    })
-                    .collect();
-                WHNF::Expr(rc(ExprF::UnionLit(l, val.normalize_to_expr(), kts)))
+                WHNF::UnionLit(l, Box::new(val), (ctx, kts))
             }
         }
     }
@@ -522,10 +558,17 @@ fn reval(ctx: &NormalizationContext, expr: OutputSubExpr) -> WHNF {
         }
         ExprF::BoolLit(b) => WHNF::BoolLit(b),
         ExprF::NaturalLit(n) => WHNF::NaturalLit(n),
+        ExprF::EmptyOptionalLit(e) => WHNF::EmptyOptionalLit(ctx.clone(), e),
+        ExprF::NEOptionalLit(e) => WHNF::NEOptionalLit(ctx.clone(), e),
         ExprF::EmptyListLit(e) => WHNF::EmptyListLit(ctx.clone(), e),
         ExprF::NEListLit(elts) => WHNF::NEListLit(vec![(ctx.clone(), elts)]),
         ExprF::RecordLit(kvs) => WHNF::RecordLit(ctx.clone(), kvs),
         ExprF::UnionType(kvs) => WHNF::UnionType(ctx.clone(), kvs),
+        ExprF::UnionLit(l, x, kts) => WHNF::UnionLit(
+            l,
+            Box::new(normalize_whnf(ctx, x)),
+            (ctx.clone(), kts),
+        ),
         _ => WHNF::Expr(expr),
     }
 }
@@ -554,6 +597,18 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
         }
         ExprF::BoolLit(b) => return WHNF::BoolLit(*b),
         ExprF::NaturalLit(n) => return WHNF::NaturalLit(*n),
+        ExprF::OldOptionalLit(None, t) => {
+            return WHNF::EmptyOptionalLit(ctx.clone(), t.clone())
+        }
+        ExprF::OldOptionalLit(Some(x), _) => {
+            return WHNF::NEOptionalLit(ctx.clone(), x.clone())
+        }
+        ExprF::EmptyOptionalLit(e) => {
+            return WHNF::EmptyOptionalLit(ctx.clone(), e.clone())
+        }
+        ExprF::NEOptionalLit(e) => {
+            return WHNF::NEOptionalLit(ctx.clone(), e.clone())
+        }
         ExprF::EmptyListLit(e) => {
             return WHNF::EmptyListLit(ctx.clone(), e.clone())
         }
@@ -566,6 +621,13 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
         ExprF::UnionType(kvs) => {
             return WHNF::UnionType(ctx.clone(), kvs.clone())
         }
+        ExprF::UnionLit(l, x, kts) => {
+            return WHNF::UnionLit(
+                l.clone(),
+                Box::new(normalize_whnf(ctx, x.clone())),
+                (ctx.clone(), kts.clone()),
+            )
+        }
         ExprF::BoolIf(b, e1, e2) => {
             let b = normalize_whnf(ctx, b.clone());
             match b {
@@ -687,6 +749,22 @@ fn normalize_last_layer(
                 t,
             ),
         },
+        Merge(
+            WHNF::RecordLit(record_ctx, mut handlers),
+            WHNF::UnionLit(l, v, (kts_ctx, kts)),
+            t,
+        ) => match handlers.remove(&l) {
+            Some(h) => {
+                let h = normalize_whnf(&kts_ctx, h);
+                return normalize_last_layer(ctx, App(h, *v));
+            }
+            // Return ownership
+            None => Merge(
+                WHNF::RecordLit(record_ctx, handlers),
+                WHNF::UnionLit(l, v, (kts_ctx, kts)),
+                t,
+            ),
+        },
         expr => expr,
     };
 
@@ -705,8 +783,7 @@ fn normalize_last_layer(
         BoolIf(BoolLit(_), _, _) => unreachable!(),
         // TODO: interpolation
         // TextLit(t) =>
-        OldOptionalLit(None, t) => Done(EmptyOptionalLit(t.roll())),
-        OldOptionalLit(Some(x), _) => Done(NEOptionalLit(x.roll())),
+        OldOptionalLit(_, _) => unreachable!(),
         BinOp(BoolAnd, BoolLit(_), BoolLit(_)) => unreachable!(),
         BinOp(BoolOr, BoolLit(_), BoolLit(_)) => unreachable!(),
         BinOp(BoolEQ, BoolLit(_), BoolLit(_)) => unreachable!(),
@@ -717,12 +794,7 @@ fn normalize_last_layer(
         BinOp(ListAppend, EmptyListLit(_), _) => unreachable!(),
         BinOp(ListAppend, _, EmptyListLit(_)) => unreachable!(),
         BinOp(ListAppend, NEListLit(_), NEListLit(_)) => unreachable!(),
-        Merge(RecordLit(handlers), UnionLit(l, v, _), _) => {
-            match handlers.get(&l) {
-                Some(h) => Continue(App(h.clone(), v.clone())),
-                None => DoneAsIs,
-            }
-        }
+        Merge(RecordLit(_), UnionLit(_, _, _), _) => unreachable!(),
         Field(RecordLit(_), _) => unreachable!(),
         Field(UnionType(_), _) => unreachable!(),
         Projection(_, ls) if ls.is_empty() => unreachable!(),
-- 
cgit v1.2.3


From 19b74fb2f0d2f69d304e14d9d3419947348c0de0 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 00:34:50 +0200
Subject: Simplify apply_builtin

---
 dhall/src/normalize.rs | 180 +++++++++++++++++++------------------------------
 1 file changed, 69 insertions(+), 111 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index d02dd80..e88cc7b 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -1,6 +1,5 @@
 #![allow(non_snake_case)]
 use std::collections::BTreeMap;
-use std::fmt;
 
 use dhall_core::context::Context;
 use dhall_core::*;
@@ -26,59 +25,40 @@ impl<'a> Typed<'a> {
     }
 }
 
-fn apply_builtin<N, E>(b: Builtin, args: &[Expr<N, E>]) -> WhatNext<N, E>
-where
-    N: fmt::Debug + Clone,
-    E: fmt::Debug + Clone,
-{
+fn apply_builtin(b: Builtin, args: &[WHNF]) -> WhatNext<X, X> {
+    let args: Vec<_> = args
+        .iter()
+        .map(|val| val.clone().normalize_to_expr().unroll())
+        .collect();
     use dhall_core::Builtin::*;
     use dhall_core::ExprF::*;
     use WhatNext::*;
-    let (ret, rest) = match (b, args) {
-        (OptionalNone, [t, rest..]) => (rc(EmptyOptionalLit(t.roll())), rest),
-        (NaturalIsZero, [NaturalLit(n), rest..]) => {
-            (rc(BoolLit(*n == 0)), rest)
+    let ret = match (b, args.as_slice()) {
+        (OptionalNone, [t]) => rc(EmptyOptionalLit(t.roll())),
+        (NaturalIsZero, [NaturalLit(n)]) => rc(BoolLit(*n == 0)),
+        (NaturalEven, [NaturalLit(n)]) => rc(BoolLit(*n % 2 == 0)),
+        (NaturalOdd, [NaturalLit(n)]) => rc(BoolLit(*n % 2 != 0)),
+        (NaturalToInteger, [NaturalLit(n)]) => rc(IntegerLit(*n as isize)),
+        (NaturalShow, [NaturalLit(n)]) => rc(TextLit(n.to_string().into())),
+        (ListLength, [_, EmptyListLit(_)]) => rc(NaturalLit(0)),
+        (ListLength, [_, NEListLit(ys)]) => rc(NaturalLit(ys.len())),
+        (ListHead, [_, EmptyListLit(t)]) => rc(EmptyOptionalLit(t.clone())),
+        (ListHead, [_, NEListLit(ys)]) => {
+            rc(NEOptionalLit(ys.first().unwrap().clone()))
         }
-        (NaturalEven, [NaturalLit(n), rest..]) => {
-            (rc(BoolLit(*n % 2 == 0)), rest)
+        (ListLast, [_, EmptyListLit(t)]) => rc(EmptyOptionalLit(t.clone())),
+        (ListLast, [_, NEListLit(ys)]) => {
+            rc(NEOptionalLit(ys.last().unwrap().clone()))
         }
-        (NaturalOdd, [NaturalLit(n), rest..]) => {
-            (rc(BoolLit(*n % 2 != 0)), rest)
-        }
-        (NaturalToInteger, [NaturalLit(n), rest..]) => {
-            (rc(IntegerLit(*n as isize)), rest)
-        }
-        (NaturalShow, [NaturalLit(n), rest..]) => {
-            (rc(TextLit(n.to_string().into())), rest)
-        }
-        (ListLength, [_, EmptyListLit(_), rest..]) => (rc(NaturalLit(0)), rest),
-        (ListLength, [_, NEListLit(ys), rest..]) => {
-            (rc(NaturalLit(ys.len())), rest)
-        }
-        (ListHead, [_, EmptyListLit(t), rest..]) => {
-            (rc(EmptyOptionalLit(t.clone())), rest)
-        }
-        (ListHead, [_, NEListLit(ys), rest..]) => {
-            (rc(NEOptionalLit(ys.first().unwrap().clone())), rest)
-        }
-        (ListLast, [_, EmptyListLit(t), rest..]) => {
-            (rc(EmptyOptionalLit(t.clone())), rest)
-        }
-        (ListLast, [_, NEListLit(ys), rest..]) => {
-            (rc(NEOptionalLit(ys.last().unwrap().clone())), rest)
-        }
-        (ListReverse, [_, EmptyListLit(t), rest..]) => {
-            (rc(EmptyListLit(t.clone())), rest)
-        }
-        (ListReverse, [_, NEListLit(ys), rest..]) => {
+        (ListReverse, [_, EmptyListLit(t)]) => rc(EmptyListLit(t.clone())),
+        (ListReverse, [_, NEListLit(ys)]) => {
             let ys = ys.iter().rev().cloned().collect();
-            (rc(NEListLit(ys)), rest)
+            rc(NEListLit(ys))
         }
-        (ListIndexed, [_, EmptyListLit(t), rest..]) => (
-            dhall::subexpr!([] : List ({ index : Natural, value : t })),
-            rest,
-        ),
-        (ListIndexed, [_, NEListLit(xs), rest..]) => {
+        (ListIndexed, [_, EmptyListLit(t)]) => {
+            dhall::subexpr!([] : List ({ index : Natural, value : t }))
+        }
+        (ListIndexed, [_, NEListLit(xs)]) => {
             let xs = xs
                 .iter()
                 .cloned()
@@ -88,9 +68,9 @@ where
                     dhall::subexpr!({ index = i, value = e })
                 })
                 .collect();
-            (rc(NEListLit(xs)), rest)
+            rc(NEListLit(xs))
         }
-        (ListBuild, [a0, g, rest..]) => {
+        (ListBuild, [a0, g]) => {
             'ret: {
                 // if let App(f2, args2) = g {
                 //     if let (Builtin(ListFold), [_, x, rest_inner..]) =
@@ -106,18 +86,15 @@ where
                 let a0 = a0.roll();
                 let a1 = shift0(1, &"x".into(), &a0);
                 let g = g.roll();
-                break 'ret (
-                    dhall::subexpr!(
-                        g
-                        (List a0)
-                        (λ(x : a0) -> λ(xs : List a1) -> [ x ] # xs)
-                        ([] : List a0)
-                    ),
-                    rest,
+                break 'ret dhall::subexpr!(
+                    g
+                    (List a0)
+                    (λ(x : a0) -> λ(xs : List a1) -> [ x ] # xs)
+                    ([] : List a0)
                 );
             }
         }
-        (OptionalBuild, [a0, g, rest..]) => {
+        (OptionalBuild, [a0, g]) => {
             'ret: {
                 // if let App(f2, args2) = g {
                 //     if let (Builtin(OptionalFold), [_, x, rest_inner..]) =
@@ -132,75 +109,64 @@ where
                 // };
                 let a0 = a0.roll();
                 let g = g.roll();
-                break 'ret (
-                    dhall::subexpr!(
-                        g
-                        (Optional a0)
-                        (λ(x: a0) -> Some x)
-                        (None a0)
-                    ),
-                    rest,
+                break 'ret dhall::subexpr!(
+                    g
+                    (Optional a0)
+                    (λ(x: a0) -> Some x)
+                    (None a0)
                 );
             }
         }
-        (ListFold, [_, EmptyListLit(_), _, _, nil, rest..]) => {
-            (nil.roll(), rest)
-        }
-        (ListFold, [_, NEListLit(xs), _, cons, nil, rest..]) => (
+        (ListFold, [_, EmptyListLit(_), _, _, nil]) => nil.roll(),
+        (ListFold, [_, NEListLit(xs), _, cons, nil]) => {
             xs.iter().rev().fold(nil.roll(), |acc, x| {
                 let x = x.clone();
                 let acc = acc.clone();
                 let cons = cons.roll();
                 dhall::subexpr!(cons x acc)
-            }),
-            rest,
-        ),
+            })
+        }
         // // fold/build fusion
         // (ListFold, [_, App(box Builtin(ListBuild), [_, x, rest..]), rest..]) => {
         //     normalize_whnf(&App(bx(x.clone()), rest.to_vec()))
         // }
-        (OptionalFold, [_, NEOptionalLit(x), _, just, _, rest..]) => {
+        (OptionalFold, [_, NEOptionalLit(x), _, just, _]) => {
             let x = x.clone();
             let just = just.roll();
-            (dhall::subexpr!(just x), rest)
+            dhall::subexpr!(just x)
         }
-        (OptionalFold, [_, EmptyOptionalLit(_), _, _, nothing, rest..]) => {
-            (nothing.roll(), rest)
+        (OptionalFold, [_, EmptyOptionalLit(_), _, _, nothing]) => {
+            nothing.roll()
         }
         // // fold/build fusion
         // (OptionalFold, [_, App(box Builtin(OptionalBuild), [_, x, rest..]), rest..]) => {
         //     normalize_whnf(&App(bx(x.clone()), rest.to_vec()))
         // }
-        (NaturalBuild, [g, rest..]) => {
-            'ret: {
-                // if let App(f2, args2) = g {
-                //     if let (Builtin(NaturalFold), [x, rest_inner..]) =
-                //         (f2.as_ref(), args2.as_slice())
-                //     {
-                //         // fold/build fusion
-                //         break 'ret (
-                //             rc(App(x.clone(), rest_inner.to_vec())),
-                //             rest,
-                //         );
-                //     }
-                // };
-                let g = g.roll();
-                break 'ret (
-                    dhall::subexpr!(g Natural (λ(x : Natural) -> x + 1) 0),
-                    rest,
-                );
-            }
-        }
-        (NaturalFold, [NaturalLit(0), _, _, zero, rest..]) => {
-            (zero.roll(), rest)
+        (NaturalBuild, [g]) => {
+            // 'ret: {
+            // if let App(f2, args2) = g {
+            //     if let (Builtin(NaturalFold), [x, rest_inner..]) =
+            //         (f2.as_ref(), args2.as_slice())
+            //     {
+            //         // fold/build fusion
+            //         break 'ret (
+            //             rc(App(x.clone(), rest_inner.to_vec())),
+            //             rest,
+            //         );
+            //     }
+            // };
+            // }
+            let g = g.roll();
+            dhall::subexpr!(g Natural (λ(x : Natural) -> x + 1) 0)
         }
-        (NaturalFold, [NaturalLit(n), t, succ, zero, rest..]) => {
+        (NaturalFold, [NaturalLit(0), _, _, zero]) => zero.roll(),
+        (NaturalFold, [NaturalLit(n), t, succ, zero]) => {
             let fold = rc(Builtin(NaturalFold));
             let n = rc(NaturalLit(n - 1));
             let t = t.roll();
             let succ = succ.roll();
             let zero = zero.roll();
-            (dhall::subexpr!(succ (fold n t succ zero)), rest)
+            dhall::subexpr!(succ (fold n t succ zero))
         }
         // (NaturalFold, Some(App(f2, args2)), _) => {
         //     match (f2.as_ref(), args2.as_slice()) {
@@ -213,11 +179,7 @@ where
         // }
         _ => return DoneAsIs,
     };
-    // Put the remaining arguments back and eval again. In most cases
-    // ret will not be of a form that can be applied, so this won't go very deep.
-    // In lots of cases, there are no remaining args so this cann will just return ret.
-    let rest = rest.iter().map(ExprF::roll);
-    Continue(rest.fold(ret, |acc, e| rc(ExprF::App(acc, e))).unroll())
+    Continue(ret.unroll())
 }
 
 // #[derive(Debug, Clone)]
@@ -403,11 +365,7 @@ impl Closure {
             }
             Closure::AppliedBuiltin(ctx, b, mut args) => {
                 args.push(val);
-                let args_unrolled: Vec<_> = args
-                    .iter()
-                    .map(|val| val.clone().normalize_to_expr().unroll())
-                    .collect();
-                match apply_builtin(b, &args_unrolled).into_value(&ctx) {
+                match apply_builtin(b, &args).into_value(&ctx) {
                     Some(v) => v,
                     None => {
                         WHNF::Closure(Closure::AppliedBuiltin(ctx, b, args))
-- 
cgit v1.2.3


From 151a14dad84d4d0f02045ea9b69d63e2cb9fe17e Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 01:55:21 +0200
Subject: Improve WHNF ergonomics

This will be needed for the apply_builtin rewrite anyways
---
 dhall/src/normalize.rs | 239 ++++++++++++++++++++++++++++---------------------
 1 file changed, 135 insertions(+), 104 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index e88cc7b..b038efd 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -208,22 +208,22 @@ fn apply_builtin(b: Builtin, args: &[WHNF]) -> WhatNext<X, X> {
 /// this means knowing just the field names.
 ///
 /// Each variant captures the relevant contexts when it is constructed. Conceptually each
-/// subexpression has its own context, but in practise contexts can be shared when sensible, to
+/// subexpression has its own context, but in practice some contexts can be shared when sensible, to
 /// avoid unnecessary allocations.
 #[derive(Debug, Clone)]
 enum WHNF {
     Closure(Closure),
     BoolLit(bool),
     NaturalLit(Natural),
-    EmptyOptionalLit(NormalizationContext, InputSubExpr),
-    NEOptionalLit(NormalizationContext, InputSubExpr),
-    EmptyListLit(NormalizationContext, InputSubExpr),
-    NEListLit(Vec<(NormalizationContext, Vec<InputSubExpr>)>),
-    RecordLit(NormalizationContext, BTreeMap<Label, InputSubExpr>),
+    EmptyOptionalLit(Now),
+    NEOptionalLit(Now),
+    EmptyListLit(Now),
+    NEListLit(Vec<Now>),
+    RecordLit(BTreeMap<Label, Now>),
     UnionType(NormalizationContext, BTreeMap<Label, Option<InputSubExpr>>),
     UnionLit(
         Label,
-        Box<WHNF>,
+        Now,
         (NormalizationContext, BTreeMap<Label, Option<InputSubExpr>>),
     ),
     Expr(OutputSubExpr),
@@ -236,29 +236,23 @@ impl WHNF {
             WHNF::Closure(c) => c.normalize_to_expr(),
             WHNF::BoolLit(b) => rc(ExprF::BoolLit(b)),
             WHNF::NaturalLit(n) => rc(ExprF::NaturalLit(n)),
-            WHNF::EmptyOptionalLit(ctx, e) => rc(ExprF::EmptyOptionalLit(
-                normalize_whnf(&ctx, e).normalize_to_expr(),
-            )),
-            WHNF::NEOptionalLit(ctx, e) => rc(ExprF::NEOptionalLit(
-                normalize_whnf(&ctx, e).normalize_to_expr(),
-            )),
-            WHNF::EmptyListLit(ctx, e) => rc(ExprF::EmptyListLit(
-                normalize_whnf(&ctx, e).normalize_to_expr(),
-            )),
+            WHNF::EmptyOptionalLit(n) => {
+                rc(ExprF::EmptyOptionalLit(n.normalize().normalize_to_expr()))
+            }
+            WHNF::NEOptionalLit(n) => {
+                rc(ExprF::NEOptionalLit(n.normalize().normalize_to_expr()))
+            }
+            WHNF::EmptyListLit(n) => {
+                rc(ExprF::EmptyListLit(n.normalize().normalize_to_expr()))
+            }
             WHNF::NEListLit(elts) => rc(ExprF::NEListLit(
                 elts.into_iter()
-                    .flat_map(|(ctx, vs)| {
-                        vs.into_iter().map(move |v| {
-                            normalize_whnf(&ctx, v).normalize_to_expr()
-                        })
-                    })
+                    .map(|n| n.normalize().normalize_to_expr())
                     .collect(),
             )),
-            WHNF::RecordLit(ctx, kvs) => rc(ExprF::RecordLit(
+            WHNF::RecordLit(kvs) => rc(ExprF::RecordLit(
                 kvs.into_iter()
-                    .map(|(k, v)| {
-                        (k, normalize_whnf(&ctx, v).normalize_to_expr())
-                    })
+                    .map(|(k, v)| (k, v.normalize().normalize_to_expr()))
                     .collect(),
             )),
             WHNF::UnionType(ctx, kts) => rc(ExprF::UnionType(
@@ -275,7 +269,7 @@ impl WHNF {
             )),
             WHNF::UnionLit(l, v, (kts_ctx, kts)) => rc(ExprF::UnionLit(
                 l,
-                v.normalize_to_expr(),
+                v.normalize().normalize_to_expr(),
                 kts.into_iter()
                     .map(|(k, v)| {
                         (
@@ -297,31 +291,19 @@ impl WHNF {
             WHNF::Expr(e) => WHNF::Expr(shift0(delta, label, &e)),
             WHNF::BoolLit(b) => WHNF::BoolLit(b),
             WHNF::NaturalLit(n) => WHNF::NaturalLit(n),
-            WHNF::EmptyOptionalLit(ctx, e) => {
-                WHNF::EmptyOptionalLit(ctx, shift0(delta, label, &e))
+            WHNF::EmptyOptionalLit(n) => {
+                WHNF::EmptyOptionalLit(n.shift0(delta, label))
             }
-            WHNF::NEOptionalLit(ctx, e) => {
-                WHNF::NEOptionalLit(ctx, shift0(delta, label, &e))
-            }
-            WHNF::EmptyListLit(ctx, e) => {
-                WHNF::EmptyListLit(ctx, shift0(delta, label, &e))
+            WHNF::NEOptionalLit(n) => {
+                WHNF::NEOptionalLit(n.shift0(delta, label))
             }
+            WHNF::EmptyListLit(n) => WHNF::EmptyListLit(n.shift0(delta, label)),
             WHNF::NEListLit(elts) => WHNF::NEListLit(
-                elts.into_iter()
-                    .map(|(ctx, vs)| {
-                        (
-                            ctx,
-                            vs.into_iter()
-                                .map(|v| shift0(delta, label, &v))
-                                .collect(),
-                        )
-                    })
-                    .collect(),
+                elts.into_iter().map(|n| n.shift0(delta, label)).collect(),
             ),
-            WHNF::RecordLit(ctx, kvs) => WHNF::RecordLit(
-                ctx,
+            WHNF::RecordLit(kvs) => WHNF::RecordLit(
                 kvs.into_iter()
-                    .map(|(k, v)| (k, shift0(delta, label, &v)))
+                    .map(|(k, v)| (k, v.shift0(delta, label)))
                     .collect(),
             ),
             WHNF::UnionType(ctx, kts) => WHNF::UnionType(
@@ -332,7 +314,7 @@ impl WHNF {
             ),
             WHNF::UnionLit(l, v, (kts_ctx, kts)) => WHNF::UnionLit(
                 l,
-                Box::new(v.shift0(delta, label)),
+                v.shift0(delta, label),
                 (
                     kts_ctx,
                     kts.into_iter()
@@ -344,9 +326,46 @@ impl WHNF {
     }
 }
 
+/// Normalize-on-write smart container. Contains either a (partially) normalized value or a
+/// non-normalized value alongside a normalization context.
+/// The name is a pun on std::borrow::Cow.
+#[derive(Debug, Clone)]
+enum Now {
+    Normalized(Box<WHNF>),
+    Unnormalized(NormalizationContext, InputSubExpr),
+}
+
+impl Now {
+    fn new(ctx: NormalizationContext, e: InputSubExpr) -> Now {
+        Now::Unnormalized(ctx, e)
+    }
+
+    fn from_whnf(v: WHNF) -> Now {
+        Now::Normalized(Box::new(v))
+    }
+
+    fn normalize(self) -> WHNF {
+        match self {
+            Now::Normalized(v) => *v,
+            Now::Unnormalized(ctx, e) => normalize_whnf(&ctx, e),
+        }
+    }
+
+    fn shift0(self, delta: isize, label: &Label) -> Self {
+        match self {
+            Now::Normalized(v) => {
+                Now::Normalized(Box::new(v.shift0(delta, label)))
+            }
+            Now::Unnormalized(ctx, e) => {
+                Now::Unnormalized(ctx, shift0(delta, label, &e))
+            }
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 enum Closure {
-    Lam(NormalizationContext, Label, InputSubExpr, InputSubExpr),
+    Lam(Label, Now, (NormalizationContext, InputSubExpr)),
     AppliedBuiltin(NormalizationContext, Builtin, Vec<WHNF>),
     UnionConstructor(
         NormalizationContext,
@@ -359,7 +378,7 @@ impl Closure {
     /// Apply the closure to a value
     fn app(self, val: WHNF) -> WHNF {
         match self {
-            Closure::Lam(ctx, x, _, e) => {
+            Closure::Lam(x, _, (ctx, e)) => {
                 let ctx2 = ctx.insert(&x, val);
                 normalize_whnf(&ctx2, e)
             }
@@ -373,7 +392,7 @@ impl Closure {
                 }
             }
             Closure::UnionConstructor(ctx, l, kts) => {
-                WHNF::UnionLit(l, Box::new(val), (ctx, kts))
+                WHNF::UnionLit(l, Now::from_whnf(val), (ctx, kts))
             }
         }
     }
@@ -381,11 +400,11 @@ impl Closure {
     /// Convert the closure back to a (normalized) syntactic expression
     fn normalize_to_expr(self) -> OutputSubExpr {
         match self {
-            Closure::Lam(ctx, x, t, e) => {
+            Closure::Lam(x, t, (ctx, e)) => {
                 let ctx2 = ctx.skip(&x);
                 rc(ExprF::Lam(
                     x.clone(),
-                    normalize_whnf(&ctx, t).normalize_to_expr(),
+                    t.normalize().normalize_to_expr(),
                     normalize_whnf(&ctx2, e).normalize_to_expr(),
                 ))
             }
@@ -419,11 +438,10 @@ impl Closure {
 
     fn shift0(self, delta: isize, label: &Label) -> Self {
         match self {
-            Closure::Lam(ctx, x, t, e) => Closure::Lam(
-                ctx,
+            Closure::Lam(x, t, (ctx, e)) => Closure::Lam(
                 x,
-                shift0(delta, label, &t),
-                shift(delta, &V(label.clone(), 1), &e),
+                t.shift0(delta, label),
+                (ctx, shift(delta, &V(label.clone(), 1), &e)),
             ),
             Closure::AppliedBuiltin(ctx, b, args) => Closure::AppliedBuiltin(
                 ctx,
@@ -508,25 +526,35 @@ impl<'a> WhatNext<'a, X, X> {
 
 fn reval(ctx: &NormalizationContext, expr: OutputSubExpr) -> WHNF {
     match expr.as_ref().embed_absurd() {
-        ExprF::Lam(x, t, e) => {
-            WHNF::Closure(Closure::Lam(ctx.clone(), x, t, e))
-        }
+        ExprF::Lam(x, t, e) => WHNF::Closure(Closure::Lam(
+            x,
+            Now::new(ctx.clone(), t),
+            (ctx.clone(), e),
+        )),
         ExprF::Builtin(b) => {
             WHNF::Closure(Closure::AppliedBuiltin(ctx.clone(), b, vec![]))
         }
         ExprF::BoolLit(b) => WHNF::BoolLit(b),
         ExprF::NaturalLit(n) => WHNF::NaturalLit(n),
-        ExprF::EmptyOptionalLit(e) => WHNF::EmptyOptionalLit(ctx.clone(), e),
-        ExprF::NEOptionalLit(e) => WHNF::NEOptionalLit(ctx.clone(), e),
-        ExprF::EmptyListLit(e) => WHNF::EmptyListLit(ctx.clone(), e),
-        ExprF::NEListLit(elts) => WHNF::NEListLit(vec![(ctx.clone(), elts)]),
-        ExprF::RecordLit(kvs) => WHNF::RecordLit(ctx.clone(), kvs),
-        ExprF::UnionType(kvs) => WHNF::UnionType(ctx.clone(), kvs),
-        ExprF::UnionLit(l, x, kts) => WHNF::UnionLit(
-            l,
-            Box::new(normalize_whnf(ctx, x)),
-            (ctx.clone(), kts),
+        ExprF::EmptyOptionalLit(e) => {
+            WHNF::EmptyOptionalLit(Now::new(ctx.clone(), e))
+        }
+        ExprF::NEOptionalLit(e) => {
+            WHNF::NEOptionalLit(Now::new(ctx.clone(), e))
+        }
+        ExprF::EmptyListLit(e) => WHNF::EmptyListLit(Now::new(ctx.clone(), e)),
+        ExprF::NEListLit(elts) => WHNF::NEListLit(
+            elts.into_iter().map(|e| Now::new(ctx.clone(), e)).collect(),
+        ),
+        ExprF::RecordLit(kvs) => WHNF::RecordLit(
+            kvs.into_iter()
+                .map(|(k, e)| (k, Now::new(ctx.clone(), e)))
+                .collect(),
         ),
+        ExprF::UnionType(kvs) => WHNF::UnionType(ctx.clone(), kvs),
+        ExprF::UnionLit(l, x, kts) => {
+            WHNF::UnionLit(l, Now::new(ctx.clone(), x), (ctx.clone(), kts))
+        }
         _ => WHNF::Expr(expr),
     }
 }
@@ -540,10 +568,9 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
         }
         ExprF::Lam(x, t, e) => {
             return WHNF::Closure(Closure::Lam(
-                ctx.clone(),
                 x.clone(),
-                t.clone(),
-                e.clone(),
+                Now::new(ctx.clone(), t.clone()),
+                (ctx.clone(), e.clone()),
             ))
         }
         ExprF::Builtin(b) => {
@@ -555,26 +582,34 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
         }
         ExprF::BoolLit(b) => return WHNF::BoolLit(*b),
         ExprF::NaturalLit(n) => return WHNF::NaturalLit(*n),
-        ExprF::OldOptionalLit(None, t) => {
-            return WHNF::EmptyOptionalLit(ctx.clone(), t.clone())
+        ExprF::OldOptionalLit(None, e) => {
+            return WHNF::EmptyOptionalLit(Now::new(ctx.clone(), e.clone()))
         }
-        ExprF::OldOptionalLit(Some(x), _) => {
-            return WHNF::NEOptionalLit(ctx.clone(), x.clone())
+        ExprF::OldOptionalLit(Some(e), _) => {
+            return WHNF::NEOptionalLit(Now::new(ctx.clone(), e.clone()))
         }
         ExprF::EmptyOptionalLit(e) => {
-            return WHNF::EmptyOptionalLit(ctx.clone(), e.clone())
+            return WHNF::EmptyOptionalLit(Now::new(ctx.clone(), e.clone()))
         }
         ExprF::NEOptionalLit(e) => {
-            return WHNF::NEOptionalLit(ctx.clone(), e.clone())
+            return WHNF::NEOptionalLit(Now::new(ctx.clone(), e.clone()))
         }
         ExprF::EmptyListLit(e) => {
-            return WHNF::EmptyListLit(ctx.clone(), e.clone())
+            return WHNF::EmptyListLit(Now::new(ctx.clone(), e.clone()))
         }
         ExprF::NEListLit(elts) => {
-            return WHNF::NEListLit(vec![(ctx.clone(), elts.clone())])
+            return WHNF::NEListLit(
+                elts.iter()
+                    .map(|e| Now::new(ctx.clone(), e.clone()))
+                    .collect(),
+            )
         }
         ExprF::RecordLit(kvs) => {
-            return WHNF::RecordLit(ctx.clone(), kvs.clone())
+            return WHNF::RecordLit(
+                kvs.iter()
+                    .map(|(k, e)| (k.clone(), Now::new(ctx.clone(), e.clone())))
+                    .collect(),
+            )
         }
         ExprF::UnionType(kvs) => {
             return WHNF::UnionType(ctx.clone(), kvs.clone())
@@ -582,7 +617,7 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
         ExprF::UnionLit(l, x, kts) => {
             return WHNF::UnionLit(
                 l.clone(),
-                Box::new(normalize_whnf(ctx, x.clone())),
+                Now::new(ctx.clone(), x.clone()),
                 (ctx.clone(), kts.clone()),
             )
         }
@@ -661,64 +696,60 @@ fn normalize_last_layer(
             return WHNF::NaturalLit(x * y)
         }
 
-        BinOp(ListAppend, WHNF::EmptyListLit(_, _), y) => return y,
-        BinOp(ListAppend, x, WHNF::EmptyListLit(_, _)) => return x,
-        BinOp(ListAppend, WHNF::NEListLit(xs), WHNF::NEListLit(ys)) => {
-            let xs = xs.into_iter();
-            let ys = ys.into_iter();
-            return WHNF::NEListLit(xs.chain(ys).collect());
+        BinOp(ListAppend, WHNF::EmptyListLit(_), y) => return y,
+        BinOp(ListAppend, x, WHNF::EmptyListLit(_)) => return x,
+        BinOp(ListAppend, WHNF::NEListLit(mut xs), WHNF::NEListLit(mut ys)) => {
+            xs.append(&mut ys);
+            return WHNF::NEListLit(xs);
         }
 
         Field(WHNF::UnionType(ctx, kts), l) => {
             return WHNF::Closure(Closure::UnionConstructor(ctx, l, kts))
         }
-        Field(WHNF::RecordLit(record_ctx, mut kvs), l) => {
+        Field(WHNF::RecordLit(mut kvs), l) => {
             match kvs.remove(&l) {
-                Some(r) => return normalize_whnf(&record_ctx, r),
+                Some(r) => return r.normalize(),
                 // Return ownership
-                None => Field(WHNF::RecordLit(record_ctx, kvs), l),
+                None => Field(WHNF::RecordLit(kvs), l),
             }
         }
         // Always simplify `x.{}` to `{}`
         Projection(_, ls) if ls.is_empty() => {
-            return WHNF::RecordLit(
-                ctx.clone(),
-                std::collections::BTreeMap::new(),
-            )
+            return WHNF::RecordLit(std::collections::BTreeMap::new())
         }
-        Projection(WHNF::RecordLit(record_ctx, mut kvs), ls) => {
+        Projection(WHNF::RecordLit(mut kvs), ls) => {
             return WHNF::RecordLit(
-                record_ctx,
                 ls.into_iter()
                     .filter_map(|l| kvs.remove(&l).map(|x| (l, x)))
                     .collect(),
             )
         }
         Merge(
-            WHNF::RecordLit(record_ctx, mut handlers),
+            WHNF::RecordLit(mut handlers),
             WHNF::Closure(Closure::UnionConstructor(ctor_ctx, l, kts)),
             t,
         ) => match handlers.remove(&l) {
-            Some(h) => return normalize_whnf(ctx, h),
+            Some(h) => return h.normalize(),
             // Return ownership
             None => Merge(
-                WHNF::RecordLit(record_ctx, handlers),
+                WHNF::RecordLit(handlers),
                 WHNF::Closure(Closure::UnionConstructor(ctor_ctx, l, kts)),
                 t,
             ),
         },
         Merge(
-            WHNF::RecordLit(record_ctx, mut handlers),
+            WHNF::RecordLit(mut handlers),
             WHNF::UnionLit(l, v, (kts_ctx, kts)),
             t,
         ) => match handlers.remove(&l) {
             Some(h) => {
-                let h = normalize_whnf(&kts_ctx, h);
-                return normalize_last_layer(ctx, App(h, *v));
+                let h = h.normalize();
+                let v = v.normalize();
+                return normalize_last_layer(ctx, App(h, v));
             }
             // Return ownership
             None => Merge(
-                WHNF::RecordLit(record_ctx, handlers),
+                WHNF::RecordLit(handlers),
                 WHNF::UnionLit(l, v, (kts_ctx, kts)),
                 t,
             ),
-- 
cgit v1.2.3


From a60cf58e5f0cc2f638b788720f9a12cabfdbe3f2 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 11:02:27 +0200
Subject: Text literals

---
 dhall/src/normalize.rs | 53 +++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 52 insertions(+), 1 deletion(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index b038efd..d006cc5 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -226,6 +226,7 @@ enum WHNF {
         Now,
         (NormalizationContext, BTreeMap<Label, Option<InputSubExpr>>),
     ),
+    TextLit(Vec<InterpolatedTextContents<Now>>),
     Expr(OutputSubExpr),
 }
 
@@ -281,6 +282,17 @@ impl WHNF {
                     })
                     .collect(),
             )),
+            WHNF::TextLit(elts) => rc(ExprF::TextLit(
+                elts.into_iter()
+                    .map(|contents| {
+                        use InterpolatedTextContents::{Expr, Text};
+                        match contents {
+                            Expr(n) => Expr(n.normalize().normalize_to_expr()),
+                            Text(s) => Text(s),
+                        }
+                    })
+                    .collect(),
+            )),
             WHNF::Expr(e) => e,
         }
     }
@@ -322,6 +334,17 @@ impl WHNF {
                         .collect(),
                 ),
             ),
+            WHNF::TextLit(elts) => WHNF::TextLit(
+                elts.into_iter()
+                    .map(|contents| {
+                        use InterpolatedTextContents::{Expr, Text};
+                        match contents {
+                            Expr(n) => Expr(n.shift0(delta, label)),
+                            Text(s) => Text(s),
+                        }
+                    })
+                    .collect(),
+            ),
         }
     }
 }
@@ -555,6 +578,17 @@ fn reval(ctx: &NormalizationContext, expr: OutputSubExpr) -> WHNF {
         ExprF::UnionLit(l, x, kts) => {
             WHNF::UnionLit(l, Now::new(ctx.clone(), x), (ctx.clone(), kts))
         }
+        ExprF::TextLit(elts) => WHNF::TextLit(
+            elts.into_iter()
+                .map(|contents| {
+                    use InterpolatedTextContents::{Expr, Text};
+                    match contents {
+                        Expr(n) => Expr(Now::new(ctx.clone(), n)),
+                        Text(s) => Text(s),
+                    }
+                })
+                .collect(),
+        ),
         _ => WHNF::Expr(expr),
     }
 }
@@ -621,6 +655,19 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
                 (ctx.clone(), kts.clone()),
             )
         }
+        ExprF::TextLit(elts) => {
+            return WHNF::TextLit(
+                elts.iter()
+                    .map(|contents| {
+                        use InterpolatedTextContents::{Expr, Text};
+                        match contents {
+                            Expr(n) => Expr(Now::new(ctx.clone(), n.clone())),
+                            Text(s) => Text(s.clone()),
+                        }
+                    })
+                    .collect(),
+            )
+        }
         ExprF::BoolIf(b, e1, e2) => {
             let b = normalize_whnf(ctx, b.clone());
             match b {
@@ -702,6 +749,10 @@ fn normalize_last_layer(
             xs.append(&mut ys);
             return WHNF::NEListLit(xs);
         }
+        BinOp(TextAppend, WHNF::TextLit(mut x), WHNF::TextLit(mut y)) => {
+            x.append(&mut y);
+            return WHNF::TextLit(x);
+        }
 
         Field(WHNF::UnionType(ctx, kts), l) => {
             return WHNF::Closure(Closure::UnionConstructor(ctx, l, kts))
@@ -779,7 +830,7 @@ fn normalize_last_layer(
         BinOp(BoolNE, BoolLit(_), BoolLit(_)) => unreachable!(),
         BinOp(NaturalPlus, NaturalLit(_), NaturalLit(_)) => unreachable!(),
         BinOp(NaturalTimes, NaturalLit(_), NaturalLit(_)) => unreachable!(),
-        BinOp(TextAppend, TextLit(x), TextLit(y)) => Done(TextLit(x + y)),
+        BinOp(TextAppend, TextLit(_), TextLit(_)) => unreachable!(),
         BinOp(ListAppend, EmptyListLit(_), _) => unreachable!(),
         BinOp(ListAppend, _, EmptyListLit(_)) => unreachable!(),
         BinOp(ListAppend, NEListLit(_), NEListLit(_)) => unreachable!(),
-- 
cgit v1.2.3


From e8d1221a5f536d1d05d2bbaf176ec8e1cdc55295 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 11:21:28 +0200
Subject: Text interpolation

---
 dhall/src/normalize.rs | 46 +++++++++++++++++++++++++++++++---------------
 1 file changed, 31 insertions(+), 15 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index d006cc5..5eada3f 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -282,17 +282,35 @@ impl WHNF {
                     })
                     .collect(),
             )),
-            WHNF::TextLit(elts) => rc(ExprF::TextLit(
-                elts.into_iter()
-                    .map(|contents| {
-                        use InterpolatedTextContents::{Expr, Text};
-                        match contents {
-                            Expr(n) => Expr(n.normalize().normalize_to_expr()),
-                            Text(s) => Text(s),
-                        }
-                    })
-                    .collect(),
-            )),
+            WHNF::TextLit(elts) => {
+                fn normalize_textlit(
+                    elts: Vec<InterpolatedTextContents<Now>>,
+                ) -> InterpolatedText<OutputSubExpr> {
+                    elts.into_iter()
+                        .flat_map(|contents| {
+                            use InterpolatedTextContents::{Expr, Text};
+                            let new_interpolated = match contents {
+                                Expr(n) => match n.normalize() {
+                                    WHNF::TextLit(elts2) => {
+                                        normalize_textlit(elts2)
+                                    }
+                                    e => InterpolatedText::from((
+                                        String::new(),
+                                        vec![(
+                                            e.normalize_to_expr(),
+                                            String::new(),
+                                        )],
+                                    )),
+                                },
+                                Text(s) => InterpolatedText::from(s),
+                            };
+                            new_interpolated.into_iter()
+                        })
+                        .collect()
+                }
+
+                rc(ExprF::TextLit(normalize_textlit(elts)))
+            }
             WHNF::Expr(e) => e,
         }
     }
@@ -821,8 +839,6 @@ fn normalize_last_layer(
         App(Builtin(_), _) => unreachable!(),
         App(Lam(_, _, _), _) => unreachable!(),
         BoolIf(BoolLit(_), _, _) => unreachable!(),
-        // TODO: interpolation
-        // TextLit(t) =>
         OldOptionalLit(_, _) => unreachable!(),
         BinOp(BoolAnd, BoolLit(_), BoolLit(_)) => unreachable!(),
         BinOp(BoolOr, BoolLit(_), BoolLit(_)) => unreachable!(),
@@ -1006,7 +1022,7 @@ mod spec_tests {
     norm!(success_prelude_Optional_unzip_1, "prelude/Optional/unzip/1");
     norm!(success_prelude_Text_concat_0, "prelude/Text/concat/0");
     norm!(success_prelude_Text_concat_1, "prelude/Text/concat/1");
-    // norm!(success_prelude_Text_concatMap_0, "prelude/Text/concatMap/0");
+    norm!(success_prelude_Text_concatMap_0, "prelude/Text/concatMap/0");
     norm!(success_prelude_Text_concatMap_1, "prelude/Text/concatMap/1");
     // norm!(success_prelude_Text_concatMapSep_0, "prelude/Text/concatMapSep/0");
     // norm!(success_prelude_Text_concatMapSep_1, "prelude/Text/concatMapSep/1");
@@ -1192,7 +1208,7 @@ mod spec_tests {
     norm!(success_unit_SomeNormalizeArguments, "unit/SomeNormalizeArguments");
     norm!(success_unit_Sort, "unit/Sort");
     norm!(success_unit_Text, "unit/Text");
-    // norm!(success_unit_TextInterpolate, "unit/TextInterpolate");
+    norm!(success_unit_TextInterpolate, "unit/TextInterpolate");
     norm!(success_unit_TextLiteral, "unit/TextLiteral");
     norm!(success_unit_TextNormalizeInterpolations, "unit/TextNormalizeInterpolations");
     norm!(success_unit_TextShow, "unit/TextShow");
-- 
cgit v1.2.3


From 07f37dc3c806355d5b7acaa7639376e837ac7ee9 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 11:43:44 +0200
Subject: Cleanup leftover normalization code

---
 dhall/src/normalize.rs | 68 ++++++++------------------------------------------
 1 file changed, 10 insertions(+), 58 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 5eada3f..75bc73c 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -543,23 +543,18 @@ impl NormalizationContext {
 }
 
 // Small enum to help with being DRY
-enum WhatNext<'a, N, E> {
+enum WhatNext<N, E> {
     // Recurse on this expression
     Continue(Expr<N, E>),
-    // The following expression is the normal form
-    Done(Expr<N, E>),
-    DoneRefSub(&'a SubExpr<N, E>),
     // The current expression is already in normal form
     DoneAsIs,
 }
 
-impl<'a> WhatNext<'a, X, X> {
+impl WhatNext<X, X> {
     fn into_value(self, ctx: &NormalizationContext) -> Option<WHNF> {
         use WhatNext::*;
         match self {
             Continue(e) => Some(normalize_whnf(ctx, e.embed_absurd().roll())),
-            Done(e) => Some(reval(ctx, e.roll())),
-            DoneRefSub(e) => Some(reval(ctx, e.clone())),
             DoneAsIs => None,
         }
     }
@@ -614,6 +609,10 @@ fn reval(ctx: &NormalizationContext, expr: OutputSubExpr) -> WHNF {
 /// Reduces the imput expression to WHNF. See doc on `WHNF` for details.
 fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
     let expr = match expr.as_ref() {
+        ExprF::Var(v) => return ctx.lookup(&v),
+        ExprF::Annot(x, _) => return normalize_whnf(ctx, x.clone()),
+        ExprF::Note(_, e) => return normalize_whnf(ctx, e.clone()),
+        ExprF::Embed(e) => return reval(ctx, e.0.clone()),
         ExprF::Let(x, _, r, b) => {
             let r = normalize_whnf(ctx, r.clone());
             return normalize_whnf(&ctx.insert(x, r), b.clone());
@@ -698,12 +697,12 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
     };
 
     // Recursively normalize all subexpressions
-    let expr: ExprF<WHNF, Label, X, Normalized<'static>> =
+    let expr: ExprF<WHNF, Label, X, X> =
         expr.as_ref().map_ref_with_special_handling_of_binders(
             |e| normalize_whnf(ctx, e.clone()),
             |x, e| normalize_whnf(&ctx.skip(x), e.clone()),
             X::clone,
-            Normalized::clone,
+            |_| unreachable!(),
             Label::clone,
         );
 
@@ -713,16 +712,12 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
 /// When all sub-expressions have been (partially) normalized, eval the remaining toplevel layer.
 fn normalize_last_layer(
     ctx: &NormalizationContext,
-    expr: ExprF<WHNF, Label, X, Normalized<'static>>,
+    expr: ExprF<WHNF, Label, X, X>,
 ) -> WHNF {
     use dhall_core::BinOp::*;
     use dhall_core::ExprF::*;
-    use WhatNext::*;
 
     let expr = match expr {
-        Var(v) => return ctx.lookup(&v),
-        Annot(x, _) => return x,
-        Note(_, e) => return e,
         App(WHNF::Closure(c), a) => return c.app(a),
 
         BinOp(BoolAnd, WHNF::BoolLit(true), y) => return y,
@@ -826,50 +821,7 @@ fn normalize_last_layer(
         expr => expr,
     };
 
-    let expr: ExprF<Expr<X, X>, Label, X, Normalized<'static>> =
-        expr.map_ref_simple(|e| e.clone().normalize_to_expr().unroll());
-
-    let what_next = match &expr {
-        Embed(e) => DoneRefSub(&e.0),
-        Annot(_, _) => unreachable!(),
-        Note(_, _) => unreachable!(),
-        Var(_) => unreachable!(),
-        Let(_, _, _, _) => unreachable!(),
-        Lam(_, _, _) => unreachable!(),
-        App(Builtin(_), _) => unreachable!(),
-        App(Lam(_, _, _), _) => unreachable!(),
-        BoolIf(BoolLit(_), _, _) => unreachable!(),
-        OldOptionalLit(_, _) => unreachable!(),
-        BinOp(BoolAnd, BoolLit(_), BoolLit(_)) => unreachable!(),
-        BinOp(BoolOr, BoolLit(_), BoolLit(_)) => unreachable!(),
-        BinOp(BoolEQ, BoolLit(_), BoolLit(_)) => unreachable!(),
-        BinOp(BoolNE, BoolLit(_), BoolLit(_)) => unreachable!(),
-        BinOp(NaturalPlus, NaturalLit(_), NaturalLit(_)) => unreachable!(),
-        BinOp(NaturalTimes, NaturalLit(_), NaturalLit(_)) => unreachable!(),
-        BinOp(TextAppend, TextLit(_), TextLit(_)) => unreachable!(),
-        BinOp(ListAppend, EmptyListLit(_), _) => unreachable!(),
-        BinOp(ListAppend, _, EmptyListLit(_)) => unreachable!(),
-        BinOp(ListAppend, NEListLit(_), NEListLit(_)) => unreachable!(),
-        Merge(RecordLit(_), UnionLit(_, _, _), _) => unreachable!(),
-        Field(RecordLit(_), _) => unreachable!(),
-        Field(UnionType(_), _) => unreachable!(),
-        Projection(_, ls) if ls.is_empty() => unreachable!(),
-        Projection(RecordLit(_), _) => unreachable!(),
-        _ => DoneAsIs,
-    };
-
-    match what_next.into_value(ctx) {
-        Some(e) => e,
-        None => reval(
-            ctx,
-            rc(expr.map_ref_simple(ExprF::roll).map_ref(
-                SubExpr::clone,
-                X::clone,
-                |_| unreachable!(),
-                Label::clone,
-            )),
-        ),
-    }
+    WHNF::Expr(rc(expr.map_ref_simple(|e| e.clone().normalize_to_expr())))
 }
 
 /// Reduce an expression to its normal form, performing beta reduction
-- 
cgit v1.2.3


From 23adedb23907b24366ae87bdd2b4a424f59d2042 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 12:06:22 +0200
Subject: More cleanup

---
 dhall/src/normalize.rs | 176 ++++++++++++++-----------------------------------
 1 file changed, 51 insertions(+), 125 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 75bc73c..0aaa582 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -25,14 +25,17 @@ impl<'a> Typed<'a> {
     }
 }
 
-fn apply_builtin(b: Builtin, args: &[WHNF]) -> WhatNext<X, X> {
+fn apply_builtin(
+    ctx: &NormalizationContext,
+    b: Builtin,
+    args: &[WHNF],
+) -> Option<WHNF> {
     let args: Vec<_> = args
         .iter()
         .map(|val| val.clone().normalize_to_expr().unroll())
         .collect();
     use dhall_core::Builtin::*;
     use dhall_core::ExprF::*;
-    use WhatNext::*;
     let ret = match (b, args.as_slice()) {
         (OptionalNone, [t]) => rc(EmptyOptionalLit(t.roll())),
         (NaturalIsZero, [NaturalLit(n)]) => rc(BoolLit(*n == 0)),
@@ -177,24 +180,52 @@ fn apply_builtin(b: Builtin, args: &[WHNF]) -> WhatNext<X, X> {
         //         _ => return rc(App(f, args)),
         //     }
         // }
-        _ => return DoneAsIs,
+        _ => return None,
     };
-    Continue(ret.unroll())
+    Some(normalize_whnf(ctx, ret.embed_absurd()))
+}
+
+#[derive(Debug, Clone)]
+enum EnvItem {
+    Expr(WHNF),
+    Skip(usize),
 }
 
-// #[derive(Debug, Clone)]
-// struct ContextualizedSubExpr {
-//     ctx: NormalizationContext,
-//     expr: SubExpr<X, Normalized<'static>>,
-// }
-// impl ContextualizedSubExpr {
-//     fn normalize_whnf(self) -> WHNF {
-//         normalize_whnf(&self.ctx, self.expr)
-//     }
-//     fn normalize_expr(self) -> OutputSubExpr {
-//         normalize_whnf(&self.ctx, self.expr).into_expr(&self.ctx)
-//     }
-// }
+#[derive(Debug, Clone)]
+struct NormalizationContext(Context<Label, EnvItem>);
+
+impl NormalizationContext {
+    fn new() -> NormalizationContext {
+        NormalizationContext(Context::new())
+    }
+    fn insert(&self, x: &Label, e: WHNF) -> NormalizationContext {
+        NormalizationContext(self.0.insert(x.clone(), EnvItem::Expr(e)))
+    }
+    fn skip(&self, x: &Label) -> NormalizationContext {
+        NormalizationContext(
+            self.0
+                .map(|l, e| {
+                    use EnvItem::*;
+                    match e {
+                        Expr(e) => Expr(e.clone().shift0(1, x)),
+                        Skip(n) if l == x => Skip(*n + 1),
+                        Skip(n) => Skip(*n),
+                    }
+                })
+                .insert(x.clone(), EnvItem::Skip(0)),
+        )
+    }
+    fn lookup(&self, var: &V<Label>) -> WHNF {
+        let V(x, n) = var;
+        match self.0.lookup(x, *n) {
+            Some(EnvItem::Expr(e)) => e.clone(),
+            Some(EnvItem::Skip(m)) => {
+                WHNF::Expr(rc(ExprF::Var(V(x.clone(), *m))))
+            }
+            None => WHNF::Expr(rc(ExprF::Var(V(x.clone(), *n)))),
+        }
+    }
+}
 
 /// A semantic value. This is partially redundant with `dhall_core::Expr`, on purpose. `Expr` should
 /// be limited to syntactic expressions: either written by the user or meant to be printed.
@@ -425,7 +456,7 @@ impl Closure {
             }
             Closure::AppliedBuiltin(ctx, b, mut args) => {
                 args.push(val);
-                match apply_builtin(b, &args).into_value(&ctx) {
+                match apply_builtin(&ctx, b, &args) {
                     Some(v) => v,
                     None => {
                         WHNF::Closure(Closure::AppliedBuiltin(ctx, b, args))
@@ -500,119 +531,14 @@ impl Closure {
     }
 }
 
-#[derive(Debug, Clone)]
-enum EnvItem {
-    Expr(WHNF),
-    Skip(usize),
-}
-
-#[derive(Debug, Clone)]
-struct NormalizationContext(Context<Label, EnvItem>);
-
-impl NormalizationContext {
-    fn new() -> NormalizationContext {
-        NormalizationContext(Context::new())
-    }
-    fn insert(&self, x: &Label, e: WHNF) -> NormalizationContext {
-        NormalizationContext(self.0.insert(x.clone(), EnvItem::Expr(e)))
-    }
-    fn skip(&self, x: &Label) -> NormalizationContext {
-        NormalizationContext(
-            self.0
-                .map(|l, e| {
-                    use EnvItem::*;
-                    match e {
-                        Expr(e) => Expr(e.clone().shift0(1, x)),
-                        Skip(n) if l == x => Skip(*n + 1),
-                        Skip(n) => Skip(*n),
-                    }
-                })
-                .insert(x.clone(), EnvItem::Skip(0)),
-        )
-    }
-    fn lookup(&self, var: &V<Label>) -> WHNF {
-        let V(x, n) = var;
-        match self.0.lookup(x, *n) {
-            Some(EnvItem::Expr(e)) => e.clone(),
-            Some(EnvItem::Skip(m)) => {
-                WHNF::Expr(rc(ExprF::Var(V(x.clone(), *m))))
-            }
-            None => WHNF::Expr(rc(ExprF::Var(V(x.clone(), *n)))),
-        }
-    }
-}
-
-// Small enum to help with being DRY
-enum WhatNext<N, E> {
-    // Recurse on this expression
-    Continue(Expr<N, E>),
-    // The current expression is already in normal form
-    DoneAsIs,
-}
-
-impl WhatNext<X, X> {
-    fn into_value(self, ctx: &NormalizationContext) -> Option<WHNF> {
-        use WhatNext::*;
-        match self {
-            Continue(e) => Some(normalize_whnf(ctx, e.embed_absurd().roll())),
-            DoneAsIs => None,
-        }
-    }
-}
-
-fn reval(ctx: &NormalizationContext, expr: OutputSubExpr) -> WHNF {
-    match expr.as_ref().embed_absurd() {
-        ExprF::Lam(x, t, e) => WHNF::Closure(Closure::Lam(
-            x,
-            Now::new(ctx.clone(), t),
-            (ctx.clone(), e),
-        )),
-        ExprF::Builtin(b) => {
-            WHNF::Closure(Closure::AppliedBuiltin(ctx.clone(), b, vec![]))
-        }
-        ExprF::BoolLit(b) => WHNF::BoolLit(b),
-        ExprF::NaturalLit(n) => WHNF::NaturalLit(n),
-        ExprF::EmptyOptionalLit(e) => {
-            WHNF::EmptyOptionalLit(Now::new(ctx.clone(), e))
-        }
-        ExprF::NEOptionalLit(e) => {
-            WHNF::NEOptionalLit(Now::new(ctx.clone(), e))
-        }
-        ExprF::EmptyListLit(e) => WHNF::EmptyListLit(Now::new(ctx.clone(), e)),
-        ExprF::NEListLit(elts) => WHNF::NEListLit(
-            elts.into_iter().map(|e| Now::new(ctx.clone(), e)).collect(),
-        ),
-        ExprF::RecordLit(kvs) => WHNF::RecordLit(
-            kvs.into_iter()
-                .map(|(k, e)| (k, Now::new(ctx.clone(), e)))
-                .collect(),
-        ),
-        ExprF::UnionType(kvs) => WHNF::UnionType(ctx.clone(), kvs),
-        ExprF::UnionLit(l, x, kts) => {
-            WHNF::UnionLit(l, Now::new(ctx.clone(), x), (ctx.clone(), kts))
-        }
-        ExprF::TextLit(elts) => WHNF::TextLit(
-            elts.into_iter()
-                .map(|contents| {
-                    use InterpolatedTextContents::{Expr, Text};
-                    match contents {
-                        Expr(n) => Expr(Now::new(ctx.clone(), n)),
-                        Text(s) => Text(s),
-                    }
-                })
-                .collect(),
-        ),
-        _ => WHNF::Expr(expr),
-    }
-}
-
 /// Reduces the imput expression to WHNF. See doc on `WHNF` for details.
 fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
     let expr = match expr.as_ref() {
         ExprF::Var(v) => return ctx.lookup(&v),
         ExprF::Annot(x, _) => return normalize_whnf(ctx, x.clone()),
         ExprF::Note(_, e) => return normalize_whnf(ctx, e.clone()),
-        ExprF::Embed(e) => return reval(ctx, e.0.clone()),
+        // TODO: wasteful to retraverse everything
+        ExprF::Embed(e) => return normalize_whnf(ctx, e.0.embed_absurd()),
         ExprF::Let(x, _, r, b) => {
             let r = normalize_whnf(ctx, r.clone());
             return normalize_whnf(&ctx.insert(x, r), b.clone());
-- 
cgit v1.2.3


From cf07992c7e5df05ba74a29dcca644e23004dc610 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 12:37:15 +0200
Subject: Rewrite apply_builtin to work on WHNFs

---
 dhall/src/normalize.rs | 312 +++++++++++++++++++++++++------------------------
 1 file changed, 160 insertions(+), 152 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 0aaa582..0381f38 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -30,159 +30,167 @@ fn apply_builtin(
     b: Builtin,
     args: &[WHNF],
 ) -> Option<WHNF> {
-    let args: Vec<_> = args
-        .iter()
-        .map(|val| val.clone().normalize_to_expr().unroll())
-        .collect();
     use dhall_core::Builtin::*;
-    use dhall_core::ExprF::*;
-    let ret = match (b, args.as_slice()) {
-        (OptionalNone, [t]) => rc(EmptyOptionalLit(t.roll())),
-        (NaturalIsZero, [NaturalLit(n)]) => rc(BoolLit(*n == 0)),
-        (NaturalEven, [NaturalLit(n)]) => rc(BoolLit(*n % 2 == 0)),
-        (NaturalOdd, [NaturalLit(n)]) => rc(BoolLit(*n % 2 != 0)),
-        (NaturalToInteger, [NaturalLit(n)]) => rc(IntegerLit(*n as isize)),
-        (NaturalShow, [NaturalLit(n)]) => rc(TextLit(n.to_string().into())),
-        (ListLength, [_, EmptyListLit(_)]) => rc(NaturalLit(0)),
-        (ListLength, [_, NEListLit(ys)]) => rc(NaturalLit(ys.len())),
-        (ListHead, [_, EmptyListLit(t)]) => rc(EmptyOptionalLit(t.clone())),
-        (ListHead, [_, NEListLit(ys)]) => {
-            rc(NEOptionalLit(ys.first().unwrap().clone()))
-        }
-        (ListLast, [_, EmptyListLit(t)]) => rc(EmptyOptionalLit(t.clone())),
-        (ListLast, [_, NEListLit(ys)]) => {
-            rc(NEOptionalLit(ys.last().unwrap().clone()))
-        }
-        (ListReverse, [_, EmptyListLit(t)]) => rc(EmptyListLit(t.clone())),
-        (ListReverse, [_, NEListLit(ys)]) => {
-            let ys = ys.iter().rev().cloned().collect();
-            rc(NEListLit(ys))
-        }
-        (ListIndexed, [_, EmptyListLit(t)]) => {
-            dhall::subexpr!([] : List ({ index : Natural, value : t }))
-        }
-        (ListIndexed, [_, NEListLit(xs)]) => {
-            let xs = xs
-                .iter()
-                .cloned()
-                .enumerate()
-                .map(|(i, e)| {
-                    let i = rc(NaturalLit(i));
-                    dhall::subexpr!({ index = i, value = e })
-                })
-                .collect();
-            rc(NEListLit(xs))
-        }
-        (ListBuild, [a0, g]) => {
-            'ret: {
-                // if let App(f2, args2) = g {
-                //     if let (Builtin(ListFold), [_, x, rest_inner..]) =
-                //         (f2.as_ref(), args2.as_slice())
-                //     {
-                //         // fold/build fusion
-                //         break 'ret (
-                //             rc(App(x.clone(), rest_inner.to_vec())),
-                //             rest,
-                //         );
-                //     }
-                // };
-                let a0 = a0.roll();
+    use Closure::AppliedBuiltin;
+    use WHNF::{
+        BoolLit, EmptyListLit, EmptyOptionalLit, Expr, NEListLit,
+        NEOptionalLit, NaturalLit, RecordLit, TextLit,
+    };
+
+    let whnf_to_expr = |v: &WHNF| v.clone().normalize_to_expr().embed_absurd();
+    let now_to_expr =
+        |v: &Now| v.clone().normalize().normalize_to_expr().embed_absurd();
+
+    let ret =
+        match (b, args) {
+            (OptionalNone, [t]) => EmptyOptionalLit(Now::from_whnf(t.clone())),
+            (NaturalIsZero, [NaturalLit(n)]) => BoolLit(*n == 0),
+            (NaturalEven, [NaturalLit(n)]) => BoolLit(*n % 2 == 0),
+            (NaturalOdd, [NaturalLit(n)]) => BoolLit(*n % 2 != 0),
+            (NaturalToInteger, [NaturalLit(n)]) => {
+                Expr(rc(ExprF::IntegerLit(*n as isize)))
+            }
+            (NaturalShow, [NaturalLit(n)]) => {
+                TextLit(vec![InterpolatedTextContents::Text(n.to_string())])
+            }
+            (ListLength, [_, EmptyListLit(_)]) => NaturalLit(0),
+            (ListLength, [_, NEListLit(xs)]) => NaturalLit(xs.len()),
+            (ListHead, [_, EmptyListLit(n)]) => EmptyOptionalLit(n.clone()),
+            (ListHead, [_, NEListLit(xs)]) => {
+                NEOptionalLit(xs.first().unwrap().clone())
+            }
+            (ListLast, [_, EmptyListLit(n)]) => EmptyOptionalLit(n.clone()),
+            (ListLast, [_, NEListLit(xs)]) => {
+                NEOptionalLit(xs.last().unwrap().clone())
+            }
+            (ListReverse, [_, EmptyListLit(n)]) => EmptyListLit(n.clone()),
+            (ListReverse, [_, NEListLit(xs)]) => {
+                let xs = xs.iter().cloned().rev().collect();
+                NEListLit(xs)
+            }
+            (ListIndexed, [_, EmptyListLit(t)]) => {
+                // TODO: avoid passing through Exprs
+                let t = now_to_expr(t);
+                EmptyListLit(Now::new(
+                    ctx.clone(),
+                    dhall::subexpr!({ index : Natural, value : t }),
+                ))
+            }
+            (ListIndexed, [_, NEListLit(xs)]) => {
+                let xs = xs
+                    .iter()
+                    .cloned()
+                    .enumerate()
+                    .map(|(i, e)| {
+                        let i = NaturalLit(i);
+                        let mut kvs = BTreeMap::new();
+                        kvs.insert("index".into(), Now::from_whnf(i));
+                        kvs.insert("value".into(), e);
+                        Now::from_whnf(RecordLit(kvs))
+                    })
+                    .collect();
+                NEListLit(xs)
+            }
+            // fold/build fusion
+            (
+                ListBuild,
+                [_, WHNF::Closure(AppliedBuiltin(_, ListFold, args))],
+            ) if args.len() == 2 => args.get(1).unwrap().clone(),
+            (
+                ListFold,
+                [_, WHNF::Closure(AppliedBuiltin(_, ListBuild, args))],
+            ) if args.len() == 2 => args.get(1).unwrap().clone(),
+            (ListBuild, [a0, g]) => {
+                // TODO: avoid passing through Exprs
+                let a0 = whnf_to_expr(a0);
                 let a1 = shift0(1, &"x".into(), &a0);
-                let g = g.roll();
-                break 'ret dhall::subexpr!(
-                    g
-                    (List a0)
-                    (λ(x : a0) -> λ(xs : List a1) -> [ x ] # xs)
-                    ([] : List a0)
-                );
+                let g = whnf_to_expr(g);
+                normalize_whnf(
+                    ctx,
+                    dhall::subexpr!(
+                        g
+                        (List a0)
+                        (λ(x : a0) -> λ(xs : List a1) -> [ x ] # xs)
+                        ([] : List a0)
+                    ),
+                )
             }
-        }
-        (OptionalBuild, [a0, g]) => {
-            'ret: {
-                // if let App(f2, args2) = g {
-                //     if let (Builtin(OptionalFold), [_, x, rest_inner..]) =
-                //         (f2.as_ref(), args2.as_slice())
-                //     {
-                //         // fold/build fusion
-                //         break 'ret (
-                //             rc(App(x.clone(), rest_inner.to_vec())),
-                //             rest,
-                //         );
-                //     }
-                // };
-                let a0 = a0.roll();
-                let g = g.roll();
-                break 'ret dhall::subexpr!(
-                    g
-                    (Optional a0)
-                    (λ(x: a0) -> Some x)
-                    (None a0)
-                );
+            (ListFold, [_, EmptyListLit(_), _, _, nil]) => nil.clone(),
+            (ListFold, [_, NEListLit(xs), _, cons, nil]) => {
+                // TODO: avoid passing through Exprs
+                let nil = whnf_to_expr(nil);
+                let cons = whnf_to_expr(cons);
+                normalize_whnf(
+                    ctx,
+                    xs.iter().rev().fold(nil, |acc, x| {
+                        let x = now_to_expr(x);
+                        let acc = acc.clone();
+                        dhall::subexpr!(cons x acc)
+                    }),
+                )
             }
-        }
-        (ListFold, [_, EmptyListLit(_), _, _, nil]) => nil.roll(),
-        (ListFold, [_, NEListLit(xs), _, cons, nil]) => {
-            xs.iter().rev().fold(nil.roll(), |acc, x| {
-                let x = x.clone();
-                let acc = acc.clone();
-                let cons = cons.roll();
-                dhall::subexpr!(cons x acc)
-            })
-        }
-        // // fold/build fusion
-        // (ListFold, [_, App(box Builtin(ListBuild), [_, x, rest..]), rest..]) => {
-        //     normalize_whnf(&App(bx(x.clone()), rest.to_vec()))
-        // }
-        (OptionalFold, [_, NEOptionalLit(x), _, just, _]) => {
-            let x = x.clone();
-            let just = just.roll();
-            dhall::subexpr!(just x)
-        }
-        (OptionalFold, [_, EmptyOptionalLit(_), _, _, nothing]) => {
-            nothing.roll()
-        }
-        // // fold/build fusion
-        // (OptionalFold, [_, App(box Builtin(OptionalBuild), [_, x, rest..]), rest..]) => {
-        //     normalize_whnf(&App(bx(x.clone()), rest.to_vec()))
-        // }
-        (NaturalBuild, [g]) => {
-            // 'ret: {
-            // if let App(f2, args2) = g {
-            //     if let (Builtin(NaturalFold), [x, rest_inner..]) =
-            //         (f2.as_ref(), args2.as_slice())
-            //     {
-            //         // fold/build fusion
-            //         break 'ret (
-            //             rc(App(x.clone(), rest_inner.to_vec())),
-            //             rest,
-            //         );
-            //     }
-            // };
-            // }
-            let g = g.roll();
-            dhall::subexpr!(g Natural (λ(x : Natural) -> x + 1) 0)
-        }
-        (NaturalFold, [NaturalLit(0), _, _, zero]) => zero.roll(),
-        (NaturalFold, [NaturalLit(n), t, succ, zero]) => {
-            let fold = rc(Builtin(NaturalFold));
-            let n = rc(NaturalLit(n - 1));
-            let t = t.roll();
-            let succ = succ.roll();
-            let zero = zero.roll();
-            dhall::subexpr!(succ (fold n t succ zero))
-        }
-        // (NaturalFold, Some(App(f2, args2)), _) => {
-        //     match (f2.as_ref(), args2.as_slice()) {
-        //         // fold/build fusion
-        //         (Builtin(NaturalBuild), [x, rest..]) => {
-        //             rc(App(x.clone(), rest.to_vec()))
-        //         }
-        //         _ => return rc(App(f, args)),
-        //     }
-        // }
-        _ => return None,
-    };
-    Some(normalize_whnf(ctx, ret.embed_absurd()))
+            // fold/build fusion
+            (
+                OptionalBuild,
+                [_, WHNF::Closure(AppliedBuiltin(_, OptionalFold, args))],
+            ) if args.len() == 2 => args.get(1).unwrap().clone(),
+            (
+                OptionalFold,
+                [_, WHNF::Closure(AppliedBuiltin(_, OptionalBuild, args))],
+            ) if args.len() == 2 => args.get(1).unwrap().clone(),
+            (OptionalBuild, [a0, g]) => {
+                // TODO: avoid passing through Exprs
+                let a0 = whnf_to_expr(a0);
+                let g = whnf_to_expr(g);
+                normalize_whnf(
+                    ctx,
+                    dhall::subexpr!(
+                        g
+                        (Optional a0)
+                        (λ(x: a0) -> Some x)
+                        (None a0)
+                    ),
+                )
+            }
+            (OptionalFold, [_, EmptyOptionalLit(_), _, _, nothing]) => {
+                nothing.clone()
+            }
+            (OptionalFold, [_, NEOptionalLit(x), _, just, _]) => {
+                // TODO: avoid passing through Exprs
+                let just = whnf_to_expr(just);
+                let x = now_to_expr(x);
+                normalize_whnf(ctx, dhall::subexpr!(just x))
+            }
+            // fold/build fusion
+            (
+                NaturalBuild,
+                [WHNF::Closure(AppliedBuiltin(_, NaturalFold, args))],
+            ) if args.len() == 1 => args.get(0).unwrap().clone(),
+            (
+                NaturalFold,
+                [WHNF::Closure(AppliedBuiltin(_, NaturalBuild, args))],
+            ) if args.len() == 1 => args.get(0).unwrap().clone(),
+            (NaturalBuild, [g]) => {
+                // TODO: avoid passing through Exprs
+                let g = whnf_to_expr(g);
+                normalize_whnf(
+                    ctx,
+                    dhall::subexpr!(g Natural (λ(x : Natural) -> x + 1) 0),
+                )
+            }
+            (NaturalFold, [NaturalLit(0), _, _, zero]) => zero.clone(),
+            (NaturalFold, [NaturalLit(n), t, succ, zero]) => {
+                // TODO: avoid passing through Exprs
+                let t = whnf_to_expr(t);
+                let succ = whnf_to_expr(succ);
+                let zero = whnf_to_expr(zero);
+                let fold = rc(ExprF::Builtin(NaturalFold));
+                let n = rc(ExprF::NaturalLit(n - 1));
+                normalize_whnf(ctx, dhall::subexpr!(succ (fold n t succ zero)))
+            }
+            _ => return None,
+        };
+    Some(ret)
 }
 
 #[derive(Debug, Clone)]
@@ -963,7 +971,7 @@ mod spec_tests {
     norm!(success_unit_LetWithType, "unit/LetWithType");
     norm!(success_unit_List, "unit/List");
     norm!(success_unit_ListBuild, "unit/ListBuild");
-    // norm!(success_unit_ListBuildFoldFusion, "unit/ListBuildFoldFusion");
+    norm!(success_unit_ListBuildFoldFusion, "unit/ListBuildFoldFusion");
     norm!(success_unit_ListBuildImplementation, "unit/ListBuildImplementation");
     norm!(success_unit_ListFold, "unit/ListFold");
     norm!(success_unit_ListFoldEmpty, "unit/ListFoldEmpty");
@@ -992,7 +1000,7 @@ mod spec_tests {
     norm!(success_unit_MergeWithTypeNormalizeArguments, "unit/MergeWithTypeNormalizeArguments");
     norm!(success_unit_Natural, "unit/Natural");
     norm!(success_unit_NaturalBuild, "unit/NaturalBuild");
-    // norm!(success_unit_NaturalBuildFoldFusion, "unit/NaturalBuildFoldFusion");
+    norm!(success_unit_NaturalBuildFoldFusion, "unit/NaturalBuildFoldFusion");
     norm!(success_unit_NaturalBuildImplementation, "unit/NaturalBuildImplementation");
     norm!(success_unit_NaturalEven, "unit/NaturalEven");
     norm!(success_unit_NaturalEvenOne, "unit/NaturalEvenOne");
@@ -1053,7 +1061,7 @@ mod spec_tests {
     norm!(success_unit_OperatorTimesTwoAndTwo, "unit/OperatorTimesTwoAndTwo");
     norm!(success_unit_Optional, "unit/Optional");
     norm!(success_unit_OptionalBuild, "unit/OptionalBuild");
-    // norm!(success_unit_OptionalBuildFoldFusion, "unit/OptionalBuildFoldFusion");
+    norm!(success_unit_OptionalBuildFoldFusion, "unit/OptionalBuildFoldFusion");
     norm!(success_unit_OptionalBuildImplementation, "unit/OptionalBuildImplementation");
     norm!(success_unit_OptionalFold, "unit/OptionalFold");
     norm!(success_unit_OptionalFoldNone, "unit/OptionalFoldNone");
-- 
cgit v1.2.3


From fd55b3e80f2955c5fe498b5f27ba24b54b9cb941 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 18:57:29 +0200
Subject: Refcount contexts to avoid clones

---
 dhall/src/normalize.rs | 80 +++++++++++++++++++++++++-------------------------
 1 file changed, 40 insertions(+), 40 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 0381f38..488885a 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -1,5 +1,6 @@
 #![allow(non_snake_case)]
 use std::collections::BTreeMap;
+use std::rc::Rc;
 
 use dhall_core::context::Context;
 use dhall_core::*;
@@ -26,7 +27,7 @@ impl<'a> Typed<'a> {
 }
 
 fn apply_builtin(
-    ctx: &NormalizationContext,
+    ctx: NormalizationContext,
     b: Builtin,
     args: &[WHNF],
 ) -> Option<WHNF> {
@@ -72,7 +73,7 @@ fn apply_builtin(
                 // TODO: avoid passing through Exprs
                 let t = now_to_expr(t);
                 EmptyListLit(Now::new(
-                    ctx.clone(),
+                    ctx,
                     dhall::subexpr!({ index : Natural, value : t }),
                 ))
             }
@@ -200,17 +201,19 @@ enum EnvItem {
 }
 
 #[derive(Debug, Clone)]
-struct NormalizationContext(Context<Label, EnvItem>);
+struct NormalizationContext(Rc<Context<Label, EnvItem>>);
 
 impl NormalizationContext {
-    fn new() -> NormalizationContext {
-        NormalizationContext(Context::new())
+    fn new() -> Self {
+        NormalizationContext(Rc::new(Context::new()))
     }
-    fn insert(&self, x: &Label, e: WHNF) -> NormalizationContext {
-        NormalizationContext(self.0.insert(x.clone(), EnvItem::Expr(e)))
+    fn insert(&self, x: &Label, e: WHNF) -> Self {
+        NormalizationContext(Rc::new(
+            self.0.insert(x.clone(), EnvItem::Expr(e)),
+        ))
     }
-    fn skip(&self, x: &Label) -> NormalizationContext {
-        NormalizationContext(
+    fn skip(&self, x: &Label) -> Self {
+        NormalizationContext(Rc::new(
             self.0
                 .map(|l, e| {
                     use EnvItem::*;
@@ -221,7 +224,7 @@ impl NormalizationContext {
                     }
                 })
                 .insert(x.clone(), EnvItem::Skip(0)),
-        )
+        ))
     }
     fn lookup(&self, var: &V<Label>) -> WHNF {
         let V(x, n) = var;
@@ -301,7 +304,8 @@ impl WHNF {
                         (
                             k,
                             v.map(|v| {
-                                normalize_whnf(&ctx, v).normalize_to_expr()
+                                normalize_whnf(ctx.clone(), v)
+                                    .normalize_to_expr()
                             }),
                         )
                     })
@@ -315,7 +319,8 @@ impl WHNF {
                         (
                             k,
                             v.map(|v| {
-                                normalize_whnf(&kts_ctx, v).normalize_to_expr()
+                                normalize_whnf(kts_ctx.clone(), v)
+                                    .normalize_to_expr()
                             }),
                         )
                     })
@@ -427,7 +432,7 @@ impl Now {
     fn normalize(self) -> WHNF {
         match self {
             Now::Normalized(v) => *v,
-            Now::Unnormalized(ctx, e) => normalize_whnf(&ctx, e),
+            Now::Unnormalized(ctx, e) => normalize_whnf(ctx, e),
         }
     }
 
@@ -460,11 +465,11 @@ impl Closure {
         match self {
             Closure::Lam(x, _, (ctx, e)) => {
                 let ctx2 = ctx.insert(&x, val);
-                normalize_whnf(&ctx2, e)
+                normalize_whnf(ctx2, e)
             }
             Closure::AppliedBuiltin(ctx, b, mut args) => {
                 args.push(val);
-                match apply_builtin(&ctx, b, &args) {
+                match apply_builtin(ctx.clone(), b, &args) {
                     Some(v) => v,
                     None => {
                         WHNF::Closure(Closure::AppliedBuiltin(ctx, b, args))
@@ -485,7 +490,7 @@ impl Closure {
                 rc(ExprF::Lam(
                     x.clone(),
                     t.normalize().normalize_to_expr(),
-                    normalize_whnf(&ctx2, e).normalize_to_expr(),
+                    normalize_whnf(ctx2, e).normalize_to_expr(),
                 ))
             }
             Closure::AppliedBuiltin(_ctx, b, args) => {
@@ -506,7 +511,8 @@ impl Closure {
                         (
                             k,
                             v.map(|v| {
-                                normalize_whnf(&ctx, v).normalize_to_expr()
+                                normalize_whnf(ctx.clone(), v)
+                                    .normalize_to_expr()
                             }),
                         )
                     })
@@ -540,7 +546,7 @@ impl Closure {
 }
 
 /// Reduces the imput expression to WHNF. See doc on `WHNF` for details.
-fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
+fn normalize_whnf(ctx: NormalizationContext, expr: InputSubExpr) -> WHNF {
     let expr = match expr.as_ref() {
         ExprF::Var(v) => return ctx.lookup(&v),
         ExprF::Annot(x, _) => return normalize_whnf(ctx, x.clone()),
@@ -548,39 +554,35 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
         // TODO: wasteful to retraverse everything
         ExprF::Embed(e) => return normalize_whnf(ctx, e.0.embed_absurd()),
         ExprF::Let(x, _, r, b) => {
-            let r = normalize_whnf(ctx, r.clone());
-            return normalize_whnf(&ctx.insert(x, r), b.clone());
+            let r = normalize_whnf(ctx.clone(), r.clone());
+            return normalize_whnf(ctx.insert(x, r), b.clone());
         }
         ExprF::Lam(x, t, e) => {
             return WHNF::Closure(Closure::Lam(
                 x.clone(),
                 Now::new(ctx.clone(), t.clone()),
-                (ctx.clone(), e.clone()),
+                (ctx, e.clone()),
             ))
         }
         ExprF::Builtin(b) => {
-            return WHNF::Closure(Closure::AppliedBuiltin(
-                ctx.clone(),
-                *b,
-                vec![],
-            ))
+            return WHNF::Closure(Closure::AppliedBuiltin(ctx, *b, vec![]))
         }
         ExprF::BoolLit(b) => return WHNF::BoolLit(*b),
         ExprF::NaturalLit(n) => return WHNF::NaturalLit(*n),
         ExprF::OldOptionalLit(None, e) => {
-            return WHNF::EmptyOptionalLit(Now::new(ctx.clone(), e.clone()))
+            return WHNF::EmptyOptionalLit(Now::new(ctx, e.clone()))
         }
         ExprF::OldOptionalLit(Some(e), _) => {
-            return WHNF::NEOptionalLit(Now::new(ctx.clone(), e.clone()))
+            return WHNF::NEOptionalLit(Now::new(ctx, e.clone()))
         }
         ExprF::EmptyOptionalLit(e) => {
-            return WHNF::EmptyOptionalLit(Now::new(ctx.clone(), e.clone()))
+            return WHNF::EmptyOptionalLit(Now::new(ctx, e.clone()))
         }
         ExprF::NEOptionalLit(e) => {
-            return WHNF::NEOptionalLit(Now::new(ctx.clone(), e.clone()))
+            return WHNF::NEOptionalLit(Now::new(ctx, e.clone()))
         }
         ExprF::EmptyListLit(e) => {
-            return WHNF::EmptyListLit(Now::new(ctx.clone(), e.clone()))
+            return WHNF::EmptyListLit(Now::new(ctx, e.clone()))
         }
         ExprF::NEListLit(elts) => {
             return WHNF::NEListLit(
@@ -596,14 +598,12 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
                     .collect(),
             )
         }
-        ExprF::UnionType(kvs) => {
-            return WHNF::UnionType(ctx.clone(), kvs.clone())
-        }
+        ExprF::UnionType(kvs) => return WHNF::UnionType(ctx, kvs.clone()),
         ExprF::UnionLit(l, x, kts) => {
             return WHNF::UnionLit(
                 l.clone(),
                 Now::new(ctx.clone(), x.clone()),
-                (ctx.clone(), kts.clone()),
+                (ctx, kts.clone()),
             )
         }
         ExprF::TextLit(elts) => {
@@ -620,7 +620,7 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
             )
         }
         ExprF::BoolIf(b, e1, e2) => {
-            let b = normalize_whnf(ctx, b.clone());
+            let b = normalize_whnf(ctx.clone(), b.clone());
             match b {
                 WHNF::BoolLit(true) => return normalize_whnf(ctx, e1.clone()),
                 WHNF::BoolLit(false) => return normalize_whnf(ctx, e2.clone()),
@@ -633,8 +633,8 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
     // Recursively normalize all subexpressions
     let expr: ExprF<WHNF, Label, X, X> =
         expr.as_ref().map_ref_with_special_handling_of_binders(
-            |e| normalize_whnf(ctx, e.clone()),
-            |x, e| normalize_whnf(&ctx.skip(x), e.clone()),
+            |e| normalize_whnf(ctx.clone(), e.clone()),
+            |x, e| normalize_whnf(ctx.skip(x), e.clone()),
             X::clone,
             |_| unreachable!(),
             Label::clone,
@@ -645,7 +645,7 @@ fn normalize_whnf(ctx: &NormalizationContext, expr: InputSubExpr) -> WHNF {
 
 /// When all sub-expressions have been (partially) normalized, eval the remaining toplevel layer.
 fn normalize_last_layer(
-    ctx: &NormalizationContext,
+    ctx: NormalizationContext,
     expr: ExprF<WHNF, Label, X, X>,
 ) -> WHNF {
     use dhall_core::BinOp::*;
@@ -768,7 +768,7 @@ fn normalize_last_layer(
 /// leave ill-typed sub-expressions unevaluated.
 ///
 fn normalize(e: InputSubExpr) -> OutputSubExpr {
-    normalize_whnf(&NormalizationContext::new(), e).normalize_to_expr()
+    normalize_whnf(NormalizationContext::new(), e).normalize_to_expr()
 }
 
 #[cfg(test)]
-- 
cgit v1.2.3


From a0c28707cbbfe334f3aebc7587a5034a49fc717c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 19:09:00 +0200
Subject: Remove WHNF/Closure distinction

---
 dhall/src/normalize.rs | 245 +++++++++++++++++++++++--------------------------
 1 file changed, 113 insertions(+), 132 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 488885a..71e8de2 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -32,11 +32,7 @@ fn apply_builtin(
     args: &[WHNF],
 ) -> Option<WHNF> {
     use dhall_core::Builtin::*;
-    use Closure::AppliedBuiltin;
-    use WHNF::{
-        BoolLit, EmptyListLit, EmptyOptionalLit, Expr, NEListLit,
-        NEOptionalLit, NaturalLit, RecordLit, TextLit,
-    };
+    use WHNF::*;
 
     let whnf_to_expr = |v: &WHNF| v.clone().normalize_to_expr().embed_absurd();
     let now_to_expr =
@@ -93,14 +89,16 @@ fn apply_builtin(
                 NEListLit(xs)
             }
             // fold/build fusion
-            (
-                ListBuild,
-                [_, WHNF::Closure(AppliedBuiltin(_, ListFold, args))],
-            ) if args.len() == 2 => args.get(1).unwrap().clone(),
-            (
-                ListFold,
-                [_, WHNF::Closure(AppliedBuiltin(_, ListBuild, args))],
-            ) if args.len() == 2 => args.get(1).unwrap().clone(),
+            (ListBuild, [_, WHNF::AppliedBuiltin(_, ListFold, args)])
+                if args.len() == 2 =>
+            {
+                args.get(1).unwrap().clone()
+            }
+            (ListFold, [_, WHNF::AppliedBuiltin(_, ListBuild, args)])
+                if args.len() == 2 =>
+            {
+                args.get(1).unwrap().clone()
+            }
             (ListBuild, [a0, g]) => {
                 // TODO: avoid passing through Exprs
                 let a0 = whnf_to_expr(a0);
@@ -133,11 +131,11 @@ fn apply_builtin(
             // fold/build fusion
             (
                 OptionalBuild,
-                [_, WHNF::Closure(AppliedBuiltin(_, OptionalFold, args))],
+                [_, WHNF::AppliedBuiltin(_, OptionalFold, args)],
             ) if args.len() == 2 => args.get(1).unwrap().clone(),
             (
                 OptionalFold,
-                [_, WHNF::Closure(AppliedBuiltin(_, OptionalBuild, args))],
+                [_, WHNF::AppliedBuiltin(_, OptionalBuild, args)],
             ) if args.len() == 2 => args.get(1).unwrap().clone(),
             (OptionalBuild, [a0, g]) => {
                 // TODO: avoid passing through Exprs
@@ -163,14 +161,16 @@ fn apply_builtin(
                 normalize_whnf(ctx, dhall::subexpr!(just x))
             }
             // fold/build fusion
-            (
-                NaturalBuild,
-                [WHNF::Closure(AppliedBuiltin(_, NaturalFold, args))],
-            ) if args.len() == 1 => args.get(0).unwrap().clone(),
-            (
-                NaturalFold,
-                [WHNF::Closure(AppliedBuiltin(_, NaturalBuild, args))],
-            ) if args.len() == 1 => args.get(0).unwrap().clone(),
+            (NaturalBuild, [WHNF::AppliedBuiltin(_, NaturalFold, args)])
+                if args.len() == 1 =>
+            {
+                args.get(0).unwrap().clone()
+            }
+            (NaturalFold, [WHNF::AppliedBuiltin(_, NaturalBuild, args)])
+                if args.len() == 1 =>
+            {
+                args.get(0).unwrap().clone()
+            }
             (NaturalBuild, [g]) => {
                 // TODO: avoid passing through Exprs
                 let g = whnf_to_expr(g);
@@ -254,7 +254,8 @@ impl NormalizationContext {
 /// avoid unnecessary allocations.
 #[derive(Debug, Clone)]
 enum WHNF {
-    Closure(Closure),
+    Lam(Label, Now, (NormalizationContext, InputSubExpr)),
+    AppliedBuiltin(NormalizationContext, Builtin, Vec<WHNF>),
     BoolLit(bool),
     NaturalLit(Natural),
     EmptyOptionalLit(Now),
@@ -263,6 +264,11 @@ enum WHNF {
     NEListLit(Vec<Now>),
     RecordLit(BTreeMap<Label, Now>),
     UnionType(NormalizationContext, BTreeMap<Label, Option<InputSubExpr>>),
+    UnionConstructor(
+        NormalizationContext,
+        Label,
+        BTreeMap<Label, Option<InputSubExpr>>,
+    ),
     UnionLit(
         Label,
         Now,
@@ -276,7 +282,25 @@ impl WHNF {
     /// Convert the value back to a (normalized) syntactic expression
     fn normalize_to_expr(self) -> OutputSubExpr {
         match self {
-            WHNF::Closure(c) => c.normalize_to_expr(),
+            WHNF::Lam(x, t, (ctx, e)) => {
+                let ctx2 = ctx.skip(&x);
+                rc(ExprF::Lam(
+                    x.clone(),
+                    t.normalize().normalize_to_expr(),
+                    normalize_whnf(ctx2, e).normalize_to_expr(),
+                ))
+            }
+            WHNF::AppliedBuiltin(_ctx, b, args) => {
+                if args.is_empty() {
+                    rc(ExprF::Builtin(b))
+                } else {
+                    args.into_iter()
+                        .map(|e| e.normalize_to_expr())
+                        .fold(rc(ExprF::Builtin(b)), |acc, e| {
+                            rc(ExprF::App(acc, e))
+                        })
+                }
+            }
             WHNF::BoolLit(b) => rc(ExprF::BoolLit(b)),
             WHNF::NaturalLit(n) => rc(ExprF::NaturalLit(n)),
             WHNF::EmptyOptionalLit(n) => {
@@ -311,6 +335,21 @@ impl WHNF {
                     })
                     .collect(),
             )),
+            WHNF::UnionConstructor(ctx, l, kts) => {
+                let kts = kts
+                    .into_iter()
+                    .map(|(k, v)| {
+                        (
+                            k,
+                            v.map(|v| {
+                                normalize_whnf(ctx.clone(), v)
+                                    .normalize_to_expr()
+                            }),
+                        )
+                    })
+                    .collect();
+                rc(ExprF::Field(rc(ExprF::UnionType(kts)), l))
+            }
             WHNF::UnionLit(l, v, (kts_ctx, kts)) => rc(ExprF::UnionLit(
                 l,
                 v.normalize().normalize_to_expr(),
@@ -359,9 +398,43 @@ impl WHNF {
         }
     }
 
+    /// Apply to a value
+    fn app(self, val: WHNF) -> WHNF {
+        match self {
+            WHNF::Lam(x, _, (ctx, e)) => {
+                let ctx2 = ctx.insert(&x, val);
+                normalize_whnf(ctx2, e)
+            }
+            WHNF::AppliedBuiltin(ctx, b, mut args) => {
+                args.push(val);
+                match apply_builtin(ctx.clone(), b, &args) {
+                    Some(v) => v,
+                    None => WHNF::AppliedBuiltin(ctx, b, args),
+                }
+            }
+            WHNF::UnionConstructor(ctx, l, kts) => {
+                WHNF::UnionLit(l, Now::from_whnf(val), (ctx, kts))
+            }
+            // Can't do anything useful, convert to expr
+            v => WHNF::Expr(rc(ExprF::App(
+                v.normalize_to_expr(),
+                val.normalize_to_expr(),
+            ))),
+        }
+    }
+
     fn shift0(self, delta: isize, label: &Label) -> Self {
         match self {
-            WHNF::Closure(c) => WHNF::Closure(c.shift0(delta, label)),
+            WHNF::Lam(x, t, (ctx, e)) => WHNF::Lam(
+                x,
+                t.shift0(delta, label),
+                (ctx, shift(delta, &V(label.clone(), 1), &e)),
+            ),
+            WHNF::AppliedBuiltin(ctx, b, args) => WHNF::AppliedBuiltin(
+                ctx,
+                b,
+                args.into_iter().map(|e| e.shift0(delta, label)).collect(),
+            ),
             WHNF::Expr(e) => WHNF::Expr(shift0(delta, label, &e)),
             WHNF::BoolLit(b) => WHNF::BoolLit(b),
             WHNF::NaturalLit(n) => WHNF::NaturalLit(n),
@@ -386,6 +459,13 @@ impl WHNF {
                     .map(|(k, v)| (k, v.map(|v| shift0(delta, label, &v))))
                     .collect(),
             ),
+            WHNF::UnionConstructor(ctx, l, kts) => {
+                let kts = kts
+                    .into_iter()
+                    .map(|(k, v)| (k, v.map(|v| shift0(delta, label, &v))))
+                    .collect();
+                WHNF::UnionConstructor(ctx, l, kts)
+            }
             WHNF::UnionLit(l, v, (kts_ctx, kts)) => WHNF::UnionLit(
                 l,
                 v.shift0(delta, label),
@@ -448,103 +528,6 @@ impl Now {
     }
 }
 
-#[derive(Debug, Clone)]
-enum Closure {
-    Lam(Label, Now, (NormalizationContext, InputSubExpr)),
-    AppliedBuiltin(NormalizationContext, Builtin, Vec<WHNF>),
-    UnionConstructor(
-        NormalizationContext,
-        Label,
-        BTreeMap<Label, Option<InputSubExpr>>,
-    ),
-}
-
-impl Closure {
-    /// Apply the closure to a value
-    fn app(self, val: WHNF) -> WHNF {
-        match self {
-            Closure::Lam(x, _, (ctx, e)) => {
-                let ctx2 = ctx.insert(&x, val);
-                normalize_whnf(ctx2, e)
-            }
-            Closure::AppliedBuiltin(ctx, b, mut args) => {
-                args.push(val);
-                match apply_builtin(ctx.clone(), b, &args) {
-                    Some(v) => v,
-                    None => {
-                        WHNF::Closure(Closure::AppliedBuiltin(ctx, b, args))
-                    }
-                }
-            }
-            Closure::UnionConstructor(ctx, l, kts) => {
-                WHNF::UnionLit(l, Now::from_whnf(val), (ctx, kts))
-            }
-        }
-    }
-
-    /// Convert the closure back to a (normalized) syntactic expression
-    fn normalize_to_expr(self) -> OutputSubExpr {
-        match self {
-            Closure::Lam(x, t, (ctx, e)) => {
-                let ctx2 = ctx.skip(&x);
-                rc(ExprF::Lam(
-                    x.clone(),
-                    t.normalize().normalize_to_expr(),
-                    normalize_whnf(ctx2, e).normalize_to_expr(),
-                ))
-            }
-            Closure::AppliedBuiltin(_ctx, b, args) => {
-                if args.is_empty() {
-                    rc(ExprF::Builtin(b))
-                } else {
-                    args.into_iter()
-                        .map(|e| e.normalize_to_expr())
-                        .fold(rc(ExprF::Builtin(b)), |acc, e| {
-                            rc(ExprF::App(acc, e))
-                        })
-                }
-            }
-            Closure::UnionConstructor(ctx, l, kts) => {
-                let kts = kts
-                    .into_iter()
-                    .map(|(k, v)| {
-                        (
-                            k,
-                            v.map(|v| {
-                                normalize_whnf(ctx.clone(), v)
-                                    .normalize_to_expr()
-                            }),
-                        )
-                    })
-                    .collect();
-                rc(ExprF::Field(rc(ExprF::UnionType(kts)), l))
-            }
-        }
-    }
-
-    fn shift0(self, delta: isize, label: &Label) -> Self {
-        match self {
-            Closure::Lam(x, t, (ctx, e)) => Closure::Lam(
-                x,
-                t.shift0(delta, label),
-                (ctx, shift(delta, &V(label.clone(), 1), &e)),
-            ),
-            Closure::AppliedBuiltin(ctx, b, args) => Closure::AppliedBuiltin(
-                ctx,
-                b,
-                args.into_iter().map(|e| e.shift0(delta, label)).collect(),
-            ),
-            Closure::UnionConstructor(ctx, l, kts) => {
-                let kts = kts
-                    .into_iter()
-                    .map(|(k, v)| (k, v.map(|v| shift0(delta, label, &v))))
-                    .collect();
-                Closure::UnionConstructor(ctx, l, kts)
-            }
-        }
-    }
-}
-
 /// Reduces the imput expression to WHNF. See doc on `WHNF` for details.
 fn normalize_whnf(ctx: NormalizationContext, expr: InputSubExpr) -> WHNF {
     let expr = match expr.as_ref() {
@@ -558,15 +541,13 @@ fn normalize_whnf(ctx: NormalizationContext, expr: InputSubExpr) -> WHNF {
             return normalize_whnf(ctx.insert(x, r), b.clone());
         }
         ExprF::Lam(x, t, e) => {
-            return WHNF::Closure(Closure::Lam(
+            return WHNF::Lam(
                 x.clone(),
                 Now::new(ctx.clone(), t.clone()),
                 (ctx, e.clone()),
-            ))
-        }
-        ExprF::Builtin(b) => {
-            return WHNF::Closure(Closure::AppliedBuiltin(ctx, *b, vec![]))
+            )
         }
+        ExprF::Builtin(b) => return WHNF::AppliedBuiltin(ctx, *b, vec![]),
         ExprF::BoolLit(b) => return WHNF::BoolLit(*b),
         ExprF::NaturalLit(n) => return WHNF::NaturalLit(*n),
         ExprF::OldOptionalLit(None, e) => {
@@ -652,7 +633,7 @@ fn normalize_last_layer(
     use dhall_core::ExprF::*;
 
     let expr = match expr {
-        App(WHNF::Closure(c), a) => return c.app(a),
+        App(v, a) => return v.app(a),
 
         BinOp(BoolAnd, WHNF::BoolLit(true), y) => return y,
         BinOp(BoolAnd, x, WHNF::BoolLit(true)) => return x,
@@ -702,7 +683,7 @@ fn normalize_last_layer(
         }
 
         Field(WHNF::UnionType(ctx, kts), l) => {
-            return WHNF::Closure(Closure::UnionConstructor(ctx, l, kts))
+            return WHNF::UnionConstructor(ctx, l, kts)
         }
         Field(WHNF::RecordLit(mut kvs), l) => {
             match kvs.remove(&l) {
@@ -724,14 +705,14 @@ fn normalize_last_layer(
         }
         Merge(
             WHNF::RecordLit(mut handlers),
-            WHNF::Closure(Closure::UnionConstructor(ctor_ctx, l, kts)),
+            WHNF::UnionConstructor(ctor_ctx, l, kts),
             t,
         ) => match handlers.remove(&l) {
             Some(h) => return h.normalize(),
             // Return ownership
             None => Merge(
                 WHNF::RecordLit(handlers),
-                WHNF::Closure(Closure::UnionConstructor(ctor_ctx, l, kts)),
+                WHNF::UnionConstructor(ctor_ctx, l, kts),
                 t,
             ),
         },
-- 
cgit v1.2.3


From cad6a315a224f4a5d63d0f49e11285304f18569c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 19:29:56 +0200
Subject: Formatting

---
 dhall/src/normalize.rs | 305 ++++++++++++++++++++++++-------------------------
 1 file changed, 152 insertions(+), 153 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 71e8de2..192a669 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -38,159 +38,158 @@ fn apply_builtin(
     let now_to_expr =
         |v: &Now| v.clone().normalize().normalize_to_expr().embed_absurd();
 
-    let ret =
-        match (b, args) {
-            (OptionalNone, [t]) => EmptyOptionalLit(Now::from_whnf(t.clone())),
-            (NaturalIsZero, [NaturalLit(n)]) => BoolLit(*n == 0),
-            (NaturalEven, [NaturalLit(n)]) => BoolLit(*n % 2 == 0),
-            (NaturalOdd, [NaturalLit(n)]) => BoolLit(*n % 2 != 0),
-            (NaturalToInteger, [NaturalLit(n)]) => {
-                Expr(rc(ExprF::IntegerLit(*n as isize)))
-            }
-            (NaturalShow, [NaturalLit(n)]) => {
-                TextLit(vec![InterpolatedTextContents::Text(n.to_string())])
-            }
-            (ListLength, [_, EmptyListLit(_)]) => NaturalLit(0),
-            (ListLength, [_, NEListLit(xs)]) => NaturalLit(xs.len()),
-            (ListHead, [_, EmptyListLit(n)]) => EmptyOptionalLit(n.clone()),
-            (ListHead, [_, NEListLit(xs)]) => {
-                NEOptionalLit(xs.first().unwrap().clone())
-            }
-            (ListLast, [_, EmptyListLit(n)]) => EmptyOptionalLit(n.clone()),
-            (ListLast, [_, NEListLit(xs)]) => {
-                NEOptionalLit(xs.last().unwrap().clone())
-            }
-            (ListReverse, [_, EmptyListLit(n)]) => EmptyListLit(n.clone()),
-            (ListReverse, [_, NEListLit(xs)]) => {
-                let xs = xs.iter().cloned().rev().collect();
-                NEListLit(xs)
-            }
-            (ListIndexed, [_, EmptyListLit(t)]) => {
-                // TODO: avoid passing through Exprs
-                let t = now_to_expr(t);
-                EmptyListLit(Now::new(
-                    ctx,
-                    dhall::subexpr!({ index : Natural, value : t }),
-                ))
-            }
-            (ListIndexed, [_, NEListLit(xs)]) => {
-                let xs = xs
-                    .iter()
-                    .cloned()
-                    .enumerate()
-                    .map(|(i, e)| {
-                        let i = NaturalLit(i);
-                        let mut kvs = BTreeMap::new();
-                        kvs.insert("index".into(), Now::from_whnf(i));
-                        kvs.insert("value".into(), e);
-                        Now::from_whnf(RecordLit(kvs))
-                    })
-                    .collect();
-                NEListLit(xs)
-            }
-            // fold/build fusion
-            (ListBuild, [_, WHNF::AppliedBuiltin(_, ListFold, args)])
-                if args.len() == 2 =>
-            {
-                args.get(1).unwrap().clone()
-            }
-            (ListFold, [_, WHNF::AppliedBuiltin(_, ListBuild, args)])
-                if args.len() == 2 =>
-            {
-                args.get(1).unwrap().clone()
-            }
-            (ListBuild, [a0, g]) => {
-                // TODO: avoid passing through Exprs
-                let a0 = whnf_to_expr(a0);
-                let a1 = shift0(1, &"x".into(), &a0);
-                let g = whnf_to_expr(g);
-                normalize_whnf(
-                    ctx,
-                    dhall::subexpr!(
-                        g
-                        (List a0)
-                        (λ(x : a0) -> λ(xs : List a1) -> [ x ] # xs)
-                        ([] : List a0)
-                    ),
-                )
-            }
-            (ListFold, [_, EmptyListLit(_), _, _, nil]) => nil.clone(),
-            (ListFold, [_, NEListLit(xs), _, cons, nil]) => {
-                // TODO: avoid passing through Exprs
-                let nil = whnf_to_expr(nil);
-                let cons = whnf_to_expr(cons);
-                normalize_whnf(
-                    ctx,
-                    xs.iter().rev().fold(nil, |acc, x| {
-                        let x = now_to_expr(x);
-                        let acc = acc.clone();
-                        dhall::subexpr!(cons x acc)
-                    }),
-                )
-            }
-            // fold/build fusion
-            (
-                OptionalBuild,
-                [_, WHNF::AppliedBuiltin(_, OptionalFold, args)],
-            ) if args.len() == 2 => args.get(1).unwrap().clone(),
-            (
-                OptionalFold,
-                [_, WHNF::AppliedBuiltin(_, OptionalBuild, args)],
-            ) if args.len() == 2 => args.get(1).unwrap().clone(),
-            (OptionalBuild, [a0, g]) => {
-                // TODO: avoid passing through Exprs
-                let a0 = whnf_to_expr(a0);
-                let g = whnf_to_expr(g);
-                normalize_whnf(
-                    ctx,
-                    dhall::subexpr!(
-                        g
-                        (Optional a0)
-                        (λ(x: a0) -> Some x)
-                        (None a0)
-                    ),
-                )
-            }
-            (OptionalFold, [_, EmptyOptionalLit(_), _, _, nothing]) => {
-                nothing.clone()
-            }
-            (OptionalFold, [_, NEOptionalLit(x), _, just, _]) => {
-                // TODO: avoid passing through Exprs
-                let just = whnf_to_expr(just);
-                let x = now_to_expr(x);
-                normalize_whnf(ctx, dhall::subexpr!(just x))
-            }
-            // fold/build fusion
-            (NaturalBuild, [WHNF::AppliedBuiltin(_, NaturalFold, args)])
-                if args.len() == 1 =>
-            {
-                args.get(0).unwrap().clone()
-            }
-            (NaturalFold, [WHNF::AppliedBuiltin(_, NaturalBuild, args)])
-                if args.len() == 1 =>
-            {
-                args.get(0).unwrap().clone()
-            }
-            (NaturalBuild, [g]) => {
-                // TODO: avoid passing through Exprs
-                let g = whnf_to_expr(g);
-                normalize_whnf(
-                    ctx,
-                    dhall::subexpr!(g Natural (λ(x : Natural) -> x + 1) 0),
-                )
-            }
-            (NaturalFold, [NaturalLit(0), _, _, zero]) => zero.clone(),
-            (NaturalFold, [NaturalLit(n), t, succ, zero]) => {
-                // TODO: avoid passing through Exprs
-                let t = whnf_to_expr(t);
-                let succ = whnf_to_expr(succ);
-                let zero = whnf_to_expr(zero);
-                let fold = rc(ExprF::Builtin(NaturalFold));
-                let n = rc(ExprF::NaturalLit(n - 1));
-                normalize_whnf(ctx, dhall::subexpr!(succ (fold n t succ zero)))
-            }
-            _ => return None,
-        };
+    let ret = match (b, args) {
+        (OptionalNone, [t]) => EmptyOptionalLit(Now::from_whnf(t.clone())),
+        (NaturalIsZero, [NaturalLit(n)]) => BoolLit(*n == 0),
+        (NaturalEven, [NaturalLit(n)]) => BoolLit(*n % 2 == 0),
+        (NaturalOdd, [NaturalLit(n)]) => BoolLit(*n % 2 != 0),
+        (NaturalToInteger, [NaturalLit(n)]) => {
+            Expr(rc(ExprF::IntegerLit(*n as isize)))
+        }
+        (NaturalShow, [NaturalLit(n)]) => {
+            TextLit(vec![InterpolatedTextContents::Text(n.to_string())])
+        }
+        (ListLength, [_, EmptyListLit(_)]) => NaturalLit(0),
+        (ListLength, [_, NEListLit(xs)]) => NaturalLit(xs.len()),
+        (ListHead, [_, EmptyListLit(n)]) => EmptyOptionalLit(n.clone()),
+        (ListHead, [_, NEListLit(xs)]) => {
+            NEOptionalLit(xs.first().unwrap().clone())
+        }
+        (ListLast, [_, EmptyListLit(n)]) => EmptyOptionalLit(n.clone()),
+        (ListLast, [_, NEListLit(xs)]) => {
+            NEOptionalLit(xs.last().unwrap().clone())
+        }
+        (ListReverse, [_, EmptyListLit(n)]) => EmptyListLit(n.clone()),
+        (ListReverse, [_, NEListLit(xs)]) => {
+            let xs = xs.iter().cloned().rev().collect();
+            NEListLit(xs)
+        }
+        (ListIndexed, [_, EmptyListLit(t)]) => {
+            // TODO: avoid passing through Exprs
+            let t = now_to_expr(t);
+            EmptyListLit(Now::new(
+                ctx,
+                dhall::subexpr!({ index : Natural, value : t }),
+            ))
+        }
+        (ListIndexed, [_, NEListLit(xs)]) => {
+            let xs = xs
+                .iter()
+                .cloned()
+                .enumerate()
+                .map(|(i, e)| {
+                    let i = NaturalLit(i);
+                    let mut kvs = BTreeMap::new();
+                    kvs.insert("index".into(), Now::from_whnf(i));
+                    kvs.insert("value".into(), e);
+                    Now::from_whnf(RecordLit(kvs))
+                })
+                .collect();
+            NEListLit(xs)
+        }
+        // fold/build fusion
+        (ListBuild, [_, WHNF::AppliedBuiltin(_, ListFold, args)])
+            if args.len() == 2 =>
+        {
+            args.get(1).unwrap().clone()
+        }
+        (ListFold, [_, WHNF::AppliedBuiltin(_, ListBuild, args)])
+            if args.len() == 2 =>
+        {
+            args.get(1).unwrap().clone()
+        }
+        (ListBuild, [a0, g]) => {
+            // TODO: avoid passing through Exprs
+            let a0 = whnf_to_expr(a0);
+            let a1 = shift0(1, &"x".into(), &a0);
+            let g = whnf_to_expr(g);
+            normalize_whnf(
+                ctx,
+                dhall::subexpr!(
+                    g
+                    (List a0)
+                    (λ(x : a0) -> λ(xs : List a1) -> [ x ] # xs)
+                    ([] : List a0)
+                ),
+            )
+        }
+        (ListFold, [_, EmptyListLit(_), _, _, nil]) => nil.clone(),
+        (ListFold, [_, NEListLit(xs), _, cons, nil]) => {
+            // TODO: avoid passing through Exprs
+            let nil = whnf_to_expr(nil);
+            let cons = whnf_to_expr(cons);
+            normalize_whnf(
+                ctx,
+                xs.iter().rev().fold(nil, |acc, x| {
+                    let x = now_to_expr(x);
+                    let acc = acc.clone();
+                    dhall::subexpr!(cons x acc)
+                }),
+            )
+        }
+        // fold/build fusion
+        (
+            OptionalBuild,
+            [_, WHNF::AppliedBuiltin(_, OptionalFold, args)],
+        ) if args.len() == 2 => args.get(1).unwrap().clone(),
+        (
+            OptionalFold,
+            [_, WHNF::AppliedBuiltin(_, OptionalBuild, args)],
+        ) if args.len() == 2 => args.get(1).unwrap().clone(),
+        (OptionalBuild, [a0, g]) => {
+            // TODO: avoid passing through Exprs
+            let a0 = whnf_to_expr(a0);
+            let g = whnf_to_expr(g);
+            normalize_whnf(
+                ctx,
+                dhall::subexpr!(
+                    g
+                    (Optional a0)
+                    (λ(x: a0) -> Some x)
+                    (None a0)
+                ),
+            )
+        }
+        (OptionalFold, [_, EmptyOptionalLit(_), _, _, nothing]) => {
+            nothing.clone()
+        }
+        (OptionalFold, [_, NEOptionalLit(x), _, just, _]) => {
+            // TODO: avoid passing through Exprs
+            let just = whnf_to_expr(just);
+            let x = now_to_expr(x);
+            normalize_whnf(ctx, dhall::subexpr!(just x))
+        }
+        // fold/build fusion
+        (NaturalBuild, [WHNF::AppliedBuiltin(_, NaturalFold, args)])
+            if args.len() == 1 =>
+        {
+            args.get(0).unwrap().clone()
+        }
+        (NaturalFold, [WHNF::AppliedBuiltin(_, NaturalBuild, args)])
+            if args.len() == 1 =>
+        {
+            args.get(0).unwrap().clone()
+        }
+        (NaturalBuild, [g]) => {
+            // TODO: avoid passing through Exprs
+            let g = whnf_to_expr(g);
+            normalize_whnf(
+                ctx,
+                dhall::subexpr!(g Natural (λ(x : Natural) -> x + 1) 0),
+            )
+        }
+        (NaturalFold, [NaturalLit(0), _, _, zero]) => zero.clone(),
+        (NaturalFold, [NaturalLit(n), t, succ, zero]) => {
+            // TODO: avoid passing through Exprs
+            let t = whnf_to_expr(t);
+            let succ = whnf_to_expr(succ);
+            let zero = whnf_to_expr(zero);
+            let fold = rc(ExprF::Builtin(NaturalFold));
+            let n = rc(ExprF::NaturalLit(n - 1));
+            normalize_whnf(ctx, dhall::subexpr!(succ (fold n t succ zero)))
+        }
+        _ => return None,
+    };
     Some(ret)
 }
 
-- 
cgit v1.2.3


From 375b27634ece7410d17fd46e0232caca696f8f74 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 19:30:01 +0200
Subject: Avoid a lot of slow Expr costruction

---
 dhall/src/normalize.rs | 125 ++++++++++++++++++++-----------------------------
 1 file changed, 52 insertions(+), 73 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 192a669..cd32e66 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -98,66 +98,49 @@ fn apply_builtin(
         {
             args.get(1).unwrap().clone()
         }
-        (ListBuild, [a0, g]) => {
-            // TODO: avoid passing through Exprs
-            let a0 = whnf_to_expr(a0);
-            let a1 = shift0(1, &"x".into(), &a0);
-            let g = whnf_to_expr(g);
-            normalize_whnf(
-                ctx,
-                dhall::subexpr!(
-                    g
-                    (List a0)
-                    (λ(x : a0) -> λ(xs : List a1) -> [ x ] # xs)
-                    ([] : List a0)
-                ),
-            )
-        }
+        // TODO: avoid passing through Exprs
+        (ListBuild, [a0, g]) => g
+            .clone()
+            .app(AppliedBuiltin(ctx.clone(), List, vec![]).app(a0.clone()))
+            .app(normalize_whnf(ctx, {
+                let a0 = whnf_to_expr(a0);
+                let a1 = shift0(1, &"x".into(), &a0);
+                dhall::subexpr!(λ(x : a0) -> λ(xs : List a1) -> [ x ] # xs)
+            }))
+            .app(EmptyListLit(Now::from_whnf(a0.clone()))),
         (ListFold, [_, EmptyListLit(_), _, _, nil]) => nil.clone(),
         (ListFold, [_, NEListLit(xs), _, cons, nil]) => {
-            // TODO: avoid passing through Exprs
-            let nil = whnf_to_expr(nil);
-            let cons = whnf_to_expr(cons);
-            normalize_whnf(
-                ctx,
-                xs.iter().rev().fold(nil, |acc, x| {
-                    let x = now_to_expr(x);
-                    let acc = acc.clone();
-                    dhall::subexpr!(cons x acc)
-                }),
-            )
+            let mut v = nil.clone();
+            for x in xs.iter().rev() {
+                v = cons.clone().app(x.clone().normalize()).app(v);
+            }
+            v
         }
         // fold/build fusion
-        (
-            OptionalBuild,
-            [_, WHNF::AppliedBuiltin(_, OptionalFold, args)],
-        ) if args.len() == 2 => args.get(1).unwrap().clone(),
-        (
-            OptionalFold,
-            [_, WHNF::AppliedBuiltin(_, OptionalBuild, args)],
-        ) if args.len() == 2 => args.get(1).unwrap().clone(),
-        (OptionalBuild, [a0, g]) => {
-            // TODO: avoid passing through Exprs
-            let a0 = whnf_to_expr(a0);
-            let g = whnf_to_expr(g);
-            normalize_whnf(
-                ctx,
-                dhall::subexpr!(
-                    g
-                    (Optional a0)
-                    (λ(x: a0) -> Some x)
-                    (None a0)
-                ),
-            )
+        (OptionalBuild, [_, WHNF::AppliedBuiltin(_, OptionalFold, args)])
+            if args.len() == 2 =>
+        {
+            args.get(1).unwrap().clone()
         }
+        (OptionalFold, [_, WHNF::AppliedBuiltin(_, OptionalBuild, args)])
+            if args.len() == 2 =>
+        {
+            args.get(1).unwrap().clone()
+        }
+        // TODO: avoid passing through Exprs
+        (OptionalBuild, [a0, g]) => g
+            .clone()
+            .app(AppliedBuiltin(ctx.clone(), Optional, vec![]).app(a0.clone()))
+            .app(normalize_whnf(ctx, {
+                let a0 = whnf_to_expr(a0);
+                dhall::subexpr!(λ(x: a0) -> Some x)
+            }))
+            .app(EmptyOptionalLit(Now::from_whnf(a0.clone()))),
         (OptionalFold, [_, EmptyOptionalLit(_), _, _, nothing]) => {
             nothing.clone()
         }
         (OptionalFold, [_, NEOptionalLit(x), _, just, _]) => {
-            // TODO: avoid passing through Exprs
-            let just = whnf_to_expr(just);
-            let x = now_to_expr(x);
-            normalize_whnf(ctx, dhall::subexpr!(just x))
+            just.clone().app(x.clone().normalize())
         }
         // fold/build fusion
         (NaturalBuild, [WHNF::AppliedBuiltin(_, NaturalFold, args)])
@@ -170,23 +153,23 @@ fn apply_builtin(
         {
             args.get(0).unwrap().clone()
         }
-        (NaturalBuild, [g]) => {
-            // TODO: avoid passing through Exprs
-            let g = whnf_to_expr(g);
-            normalize_whnf(
+        // TODO: avoid passing through Exprs
+        (NaturalBuild, [g]) => g
+            .clone()
+            .app(AppliedBuiltin(ctx.clone(), Natural, vec![]))
+            .app(normalize_whnf(
                 ctx,
-                dhall::subexpr!(g Natural (λ(x : Natural) -> x + 1) 0),
-            )
-        }
+                dhall::subexpr!((λ(x : Natural) -> x + 1)),
+            ))
+            .app(NaturalLit(0)),
         (NaturalFold, [NaturalLit(0), _, _, zero]) => zero.clone(),
         (NaturalFold, [NaturalLit(n), t, succ, zero]) => {
-            // TODO: avoid passing through Exprs
-            let t = whnf_to_expr(t);
-            let succ = whnf_to_expr(succ);
-            let zero = whnf_to_expr(zero);
-            let fold = rc(ExprF::Builtin(NaturalFold));
-            let n = rc(ExprF::NaturalLit(n - 1));
-            normalize_whnf(ctx, dhall::subexpr!(succ (fold n t succ zero)))
+            let fold = AppliedBuiltin(ctx, NaturalFold, vec![])
+                .app(NaturalLit(n - 1))
+                .app(t.clone())
+                .app(succ.clone())
+                .app(zero.clone());
+            succ.clone().app(fold)
         }
         _ => return None,
     };
@@ -290,15 +273,11 @@ impl WHNF {
                 ))
             }
             WHNF::AppliedBuiltin(_ctx, b, args) => {
-                if args.is_empty() {
-                    rc(ExprF::Builtin(b))
-                } else {
-                    args.into_iter()
-                        .map(|e| e.normalize_to_expr())
-                        .fold(rc(ExprF::Builtin(b)), |acc, e| {
-                            rc(ExprF::App(acc, e))
-                        })
+                let mut e = WHNF::Expr(rc(ExprF::Builtin(b)));
+                for v in args {
+                    e = e.app(v);
                 }
+                e.normalize_to_expr()
             }
             WHNF::BoolLit(b) => rc(ExprF::BoolLit(b)),
             WHNF::NaturalLit(n) => rc(ExprF::NaturalLit(n)),
-- 
cgit v1.2.3


From c8a24f23dc87fa741fad06957683fbe029bba85e Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 19:57:18 +0200
Subject: Introduce special closures to avoid constructing exprs

---
 dhall/src/normalize.rs | 101 ++++++++++++++++++++++++++++++++-----------------
 1 file changed, 67 insertions(+), 34 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index cd32e66..141320f 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -34,10 +34,6 @@ fn apply_builtin(
     use dhall_core::Builtin::*;
     use WHNF::*;
 
-    let whnf_to_expr = |v: &WHNF| v.clone().normalize_to_expr().embed_absurd();
-    let now_to_expr =
-        |v: &Now| v.clone().normalize().normalize_to_expr().embed_absurd();
-
     let ret = match (b, args) {
         (OptionalNone, [t]) => EmptyOptionalLit(Now::from_whnf(t.clone())),
         (NaturalIsZero, [NaturalLit(n)]) => BoolLit(*n == 0),
@@ -66,7 +62,7 @@ fn apply_builtin(
         }
         (ListIndexed, [_, EmptyListLit(t)]) => {
             // TODO: avoid passing through Exprs
-            let t = now_to_expr(t);
+            let t = t.clone().normalize().normalize_to_expr().embed_absurd();
             EmptyListLit(Now::new(
                 ctx,
                 dhall::subexpr!({ index : Natural, value : t }),
@@ -98,16 +94,11 @@ fn apply_builtin(
         {
             args.get(1).unwrap().clone()
         }
-        // TODO: avoid passing through Exprs
-        (ListBuild, [a0, g]) => g
+        (ListBuild, [t, g]) => g
             .clone()
-            .app(AppliedBuiltin(ctx.clone(), List, vec![]).app(a0.clone()))
-            .app(normalize_whnf(ctx, {
-                let a0 = whnf_to_expr(a0);
-                let a1 = shift0(1, &"x".into(), &a0);
-                dhall::subexpr!(λ(x : a0) -> λ(xs : List a1) -> [ x ] # xs)
-            }))
-            .app(EmptyListLit(Now::from_whnf(a0.clone()))),
+            .app(AppliedBuiltin(ctx.clone(), List, vec![]).app(t.clone()))
+            .app(ListConsClosure(Now::from_whnf(t.clone()), None))
+            .app(EmptyListLit(Now::from_whnf(t.clone()))),
         (ListFold, [_, EmptyListLit(_), _, _, nil]) => nil.clone(),
         (ListFold, [_, NEListLit(xs), _, cons, nil]) => {
             let mut v = nil.clone();
@@ -127,15 +118,11 @@ fn apply_builtin(
         {
             args.get(1).unwrap().clone()
         }
-        // TODO: avoid passing through Exprs
-        (OptionalBuild, [a0, g]) => g
+        (OptionalBuild, [t, g]) => g
             .clone()
-            .app(AppliedBuiltin(ctx.clone(), Optional, vec![]).app(a0.clone()))
-            .app(normalize_whnf(ctx, {
-                let a0 = whnf_to_expr(a0);
-                dhall::subexpr!(λ(x: a0) -> Some x)
-            }))
-            .app(EmptyOptionalLit(Now::from_whnf(a0.clone()))),
+            .app(AppliedBuiltin(ctx.clone(), Optional, vec![]).app(t.clone()))
+            .app(SomeConstructorClosure(Now::from_whnf(t.clone())))
+            .app(EmptyOptionalLit(Now::from_whnf(t.clone()))),
         (OptionalFold, [_, EmptyOptionalLit(_), _, _, nothing]) => {
             nothing.clone()
         }
@@ -153,14 +140,10 @@ fn apply_builtin(
         {
             args.get(0).unwrap().clone()
         }
-        // TODO: avoid passing through Exprs
         (NaturalBuild, [g]) => g
             .clone()
             .app(AppliedBuiltin(ctx.clone(), Natural, vec![]))
-            .app(normalize_whnf(
-                ctx,
-                dhall::subexpr!((λ(x : Natural) -> x + 1)),
-            ))
+            .app(NaturalSuccClosure)
             .app(NaturalLit(0)),
         (NaturalFold, [NaturalLit(0), _, _, zero]) => zero.clone(),
         (NaturalFold, [NaturalLit(n), t, succ, zero]) => {
@@ -236,8 +219,17 @@ impl NormalizationContext {
 /// avoid unnecessary allocations.
 #[derive(Debug, Clone)]
 enum WHNF {
+    /// Closures
     Lam(Label, Now, (NormalizationContext, InputSubExpr)),
     AppliedBuiltin(NormalizationContext, Builtin, Vec<WHNF>),
+    /// `λ(x: a) -> Some x`
+    SomeConstructorClosure(Now),
+    /// `λ(x : a) -> λ(xs : List a) -> [ x ] # xs
+    /// `λ(xs : List a) -> [ x ] # xs
+    ListConsClosure(Now, Option<Now>),
+    /// `λ(x : Natural) -> x + 1`
+    NaturalSuccClosure,
+
     BoolLit(bool),
     NaturalLit(Natural),
     EmptyOptionalLit(Now),
@@ -279,6 +271,24 @@ impl WHNF {
                 }
                 e.normalize_to_expr()
             }
+            WHNF::SomeConstructorClosure(n) => {
+                let a = n.normalize().normalize_to_expr();
+                dhall::subexpr!(λ(x: a) -> Some x)
+            }
+            WHNF::ListConsClosure(n, None) => {
+                let a = n.normalize().normalize_to_expr();
+                // Avoid accidental capture of the new `x` variable
+                let a1 = shift0(1, &"x".into(), &a);
+                dhall::subexpr!(λ(x : a) -> λ(xs : List a1) -> [ x ] # xs)
+            }
+            WHNF::ListConsClosure(n, Some(v)) => {
+                let v = v.normalize().normalize_to_expr();
+                let a = n.normalize().normalize_to_expr();
+                dhall::subexpr!(λ(xs : List a) -> [ v ] # xs)
+            }
+            WHNF::NaturalSuccClosure => {
+                dhall::subexpr!(λ(x : Natural) -> x + 1)
+            }
             WHNF::BoolLit(b) => rc(ExprF::BoolLit(b)),
             WHNF::NaturalLit(n) => rc(ExprF::NaturalLit(n)),
             WHNF::EmptyOptionalLit(n) => {
@@ -378,25 +388,40 @@ impl WHNF {
 
     /// Apply to a value
     fn app(self, val: WHNF) -> WHNF {
-        match self {
-            WHNF::Lam(x, _, (ctx, e)) => {
+        match (self, val) {
+            (WHNF::Lam(x, _, (ctx, e)), val) => {
                 let ctx2 = ctx.insert(&x, val);
                 normalize_whnf(ctx2, e)
             }
-            WHNF::AppliedBuiltin(ctx, b, mut args) => {
+            (WHNF::AppliedBuiltin(ctx, b, mut args), val) => {
                 args.push(val);
                 match apply_builtin(ctx.clone(), b, &args) {
                     Some(v) => v,
                     None => WHNF::AppliedBuiltin(ctx, b, args),
                 }
             }
-            WHNF::UnionConstructor(ctx, l, kts) => {
+            (WHNF::SomeConstructorClosure(_), val) => {
+                WHNF::NEOptionalLit(Now::from_whnf(val))
+            }
+            (WHNF::ListConsClosure(t, None), val) => {
+                WHNF::ListConsClosure(t, Some(Now::from_whnf(val)))
+            }
+            (WHNF::ListConsClosure(_, Some(x)), WHNF::EmptyListLit(_)) => {
+                WHNF::NEListLit(vec![x])
+            }
+            (WHNF::ListConsClosure(_, Some(x)), WHNF::NEListLit(xs)) => {
+                WHNF::NEListLit(std::iter::once(x).chain(xs).collect())
+            }
+            (WHNF::NaturalSuccClosure, WHNF::NaturalLit(n)) => {
+                WHNF::NaturalLit(n + 1)
+            }
+            (WHNF::UnionConstructor(ctx, l, kts), val) => {
                 WHNF::UnionLit(l, Now::from_whnf(val), (ctx, kts))
             }
             // Can't do anything useful, convert to expr
-            v => WHNF::Expr(rc(ExprF::App(
-                v.normalize_to_expr(),
-                val.normalize_to_expr(),
+            (f, a) => WHNF::Expr(rc(ExprF::App(
+                f.normalize_to_expr(),
+                a.normalize_to_expr(),
             ))),
         }
     }
@@ -413,6 +438,14 @@ impl WHNF {
                 b,
                 args.into_iter().map(|e| e.shift0(delta, label)).collect(),
             ),
+            WHNF::SomeConstructorClosure(n) => {
+                WHNF::SomeConstructorClosure(n.shift0(delta, label))
+            }
+            WHNF::ListConsClosure(t, v) => WHNF::ListConsClosure(
+                t.shift0(delta, label),
+                v.map(|v| v.shift0(delta, label)),
+            ),
+            WHNF::NaturalSuccClosure => WHNF::NaturalSuccClosure,
             WHNF::Expr(e) => WHNF::Expr(shift0(delta, label, &e)),
             WHNF::BoolLit(b) => WHNF::BoolLit(b),
             WHNF::NaturalLit(n) => WHNF::NaturalLit(n),
-- 
cgit v1.2.3


From 2afd0d7795f4241f0cf1a2b088723320c9260dd5 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 20:03:10 +0200
Subject: Remove last remnant of expr building

---
 dhall/src/normalize.rs | 41 +++++++++++++++++++++++++++++------------
 1 file changed, 29 insertions(+), 12 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 141320f..9847c27 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -3,10 +3,13 @@ use std::collections::BTreeMap;
 use std::rc::Rc;
 
 use dhall_core::context::Context;
-use dhall_core::*;
+use dhall_core::{
+    rc, shift, shift0, Builtin, ExprF, Integer, InterpolatedText,
+    InterpolatedTextContents, Label, Natural, SubExpr, V, X,
+};
 use dhall_generator as dhall;
 
-use crate::expr::*;
+use crate::expr::{Normalized, Typed};
 
 type InputSubExpr = SubExpr<X, Normalized<'static>>;
 type OutputSubExpr = SubExpr<X, X>;
@@ -39,9 +42,7 @@ fn apply_builtin(
         (NaturalIsZero, [NaturalLit(n)]) => BoolLit(*n == 0),
         (NaturalEven, [NaturalLit(n)]) => BoolLit(*n % 2 == 0),
         (NaturalOdd, [NaturalLit(n)]) => BoolLit(*n % 2 != 0),
-        (NaturalToInteger, [NaturalLit(n)]) => {
-            Expr(rc(ExprF::IntegerLit(*n as isize)))
-        }
+        (NaturalToInteger, [NaturalLit(n)]) => IntegerLit(*n as isize),
         (NaturalShow, [NaturalLit(n)]) => {
             TextLit(vec![InterpolatedTextContents::Text(n.to_string())])
         }
@@ -61,12 +62,13 @@ fn apply_builtin(
             NEListLit(xs)
         }
         (ListIndexed, [_, EmptyListLit(t)]) => {
-            // TODO: avoid passing through Exprs
-            let t = t.clone().normalize().normalize_to_expr().embed_absurd();
-            EmptyListLit(Now::new(
-                ctx,
-                dhall::subexpr!({ index : Natural, value : t }),
-            ))
+            let mut kts = BTreeMap::new();
+            kts.insert(
+                "index".into(),
+                Now::from_whnf(AppliedBuiltin(ctx, Natural, vec![])),
+            );
+            kts.insert("value".into(), t.clone());
+            EmptyListLit(Now::from_whnf(RecordType(kts)))
         }
         (ListIndexed, [_, NEListLit(xs)]) => {
             let xs = xs
@@ -232,11 +234,13 @@ enum WHNF {
 
     BoolLit(bool),
     NaturalLit(Natural),
+    IntegerLit(Integer),
     EmptyOptionalLit(Now),
     NEOptionalLit(Now),
     EmptyListLit(Now),
     NEListLit(Vec<Now>),
     RecordLit(BTreeMap<Label, Now>),
+    RecordType(BTreeMap<Label, Now>),
     UnionType(NormalizationContext, BTreeMap<Label, Option<InputSubExpr>>),
     UnionConstructor(
         NormalizationContext,
@@ -291,6 +295,7 @@ impl WHNF {
             }
             WHNF::BoolLit(b) => rc(ExprF::BoolLit(b)),
             WHNF::NaturalLit(n) => rc(ExprF::NaturalLit(n)),
+            WHNF::IntegerLit(n) => rc(ExprF::IntegerLit(n)),
             WHNF::EmptyOptionalLit(n) => {
                 rc(ExprF::EmptyOptionalLit(n.normalize().normalize_to_expr()))
             }
@@ -310,6 +315,11 @@ impl WHNF {
                     .map(|(k, v)| (k, v.normalize().normalize_to_expr()))
                     .collect(),
             )),
+            WHNF::RecordType(kts) => rc(ExprF::RecordType(
+                kts.into_iter()
+                    .map(|(k, v)| (k, v.normalize().normalize_to_expr()))
+                    .collect(),
+            )),
             WHNF::UnionType(ctx, kts) => rc(ExprF::UnionType(
                 kts.into_iter()
                     .map(|(k, v)| {
@@ -446,9 +456,9 @@ impl WHNF {
                 v.map(|v| v.shift0(delta, label)),
             ),
             WHNF::NaturalSuccClosure => WHNF::NaturalSuccClosure,
-            WHNF::Expr(e) => WHNF::Expr(shift0(delta, label, &e)),
             WHNF::BoolLit(b) => WHNF::BoolLit(b),
             WHNF::NaturalLit(n) => WHNF::NaturalLit(n),
+            WHNF::IntegerLit(n) => WHNF::IntegerLit(n),
             WHNF::EmptyOptionalLit(n) => {
                 WHNF::EmptyOptionalLit(n.shift0(delta, label))
             }
@@ -464,6 +474,11 @@ impl WHNF {
                     .map(|(k, v)| (k, v.shift0(delta, label)))
                     .collect(),
             ),
+            WHNF::RecordType(kts) => WHNF::RecordType(
+                kts.into_iter()
+                    .map(|(k, v)| (k, v.shift0(delta, label)))
+                    .collect(),
+            ),
             WHNF::UnionType(ctx, kts) => WHNF::UnionType(
                 ctx,
                 kts.into_iter()
@@ -498,6 +513,7 @@ impl WHNF {
                     })
                     .collect(),
             ),
+            WHNF::Expr(e) => WHNF::Expr(shift0(delta, label, &e)),
         }
     }
 }
@@ -747,6 +763,7 @@ fn normalize_last_layer(
         expr => expr,
     };
 
+    // Couldn't do anything useful, so just normalize subexpressions
     WHNF::Expr(rc(expr.map_ref_simple(|e| e.clone().normalize_to_expr())))
 }
 
-- 
cgit v1.2.3


From 7c7cc2164ea6e5996bf236a7f927307da2e5edd5 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 20:12:30 +0200
Subject: Swap import

---
 dhall/src/normalize.rs | 116 +++++++++++++++++++++++--------------------------
 1 file changed, 54 insertions(+), 62 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 9847c27..26d062b 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -657,106 +657,98 @@ fn normalize_last_layer(
     expr: ExprF<WHNF, Label, X, X>,
 ) -> WHNF {
     use dhall_core::BinOp::*;
-    use dhall_core::ExprF::*;
+    use WHNF::*;
 
     let expr = match expr {
-        App(v, a) => return v.app(a),
+        ExprF::App(v, a) => return v.app(a),
 
-        BinOp(BoolAnd, WHNF::BoolLit(true), y) => return y,
-        BinOp(BoolAnd, x, WHNF::BoolLit(true)) => return x,
-        BinOp(BoolAnd, WHNF::BoolLit(false), _) => return WHNF::BoolLit(false),
-        BinOp(BoolAnd, _, WHNF::BoolLit(false)) => return WHNF::BoolLit(false),
-        BinOp(BoolOr, WHNF::BoolLit(true), _) => return WHNF::BoolLit(true),
-        BinOp(BoolOr, _, WHNF::BoolLit(true)) => return WHNF::BoolLit(true),
-        BinOp(BoolOr, WHNF::BoolLit(false), y) => return y,
-        BinOp(BoolOr, x, WHNF::BoolLit(false)) => return x,
-        BinOp(BoolEQ, WHNF::BoolLit(true), y) => return y,
-        BinOp(BoolEQ, x, WHNF::BoolLit(true)) => return x,
-        BinOp(BoolNE, WHNF::BoolLit(false), y) => return y,
-        BinOp(BoolNE, x, WHNF::BoolLit(false)) => return x,
-        BinOp(BoolEQ, WHNF::BoolLit(x), WHNF::BoolLit(y)) => {
-            return WHNF::BoolLit(x == y)
-        }
-        BinOp(BoolNE, WHNF::BoolLit(x), WHNF::BoolLit(y)) => {
-            return WHNF::BoolLit(x != y)
-        }
+        ExprF::BinOp(BoolAnd, BoolLit(true), y) => return y,
+        ExprF::BinOp(BoolAnd, x, BoolLit(true)) => return x,
+        ExprF::BinOp(BoolAnd, BoolLit(false), _) => return BoolLit(false),
+        ExprF::BinOp(BoolAnd, _, BoolLit(false)) => return BoolLit(false),
+        ExprF::BinOp(BoolOr, BoolLit(true), _) => return BoolLit(true),
+        ExprF::BinOp(BoolOr, _, BoolLit(true)) => return BoolLit(true),
+        ExprF::BinOp(BoolOr, BoolLit(false), y) => return y,
+        ExprF::BinOp(BoolOr, x, BoolLit(false)) => return x,
+        ExprF::BinOp(BoolEQ, BoolLit(true), y) => return y,
+        ExprF::BinOp(BoolEQ, x, BoolLit(true)) => return x,
+        ExprF::BinOp(BoolNE, BoolLit(false), y) => return y,
+        ExprF::BinOp(BoolNE, x, BoolLit(false)) => return x,
+        ExprF::BinOp(BoolEQ, BoolLit(x), BoolLit(y)) => return BoolLit(x == y),
+        ExprF::BinOp(BoolNE, BoolLit(x), BoolLit(y)) => return BoolLit(x != y),
 
-        BinOp(NaturalPlus, WHNF::NaturalLit(0), y) => return y,
-        BinOp(NaturalPlus, x, WHNF::NaturalLit(0)) => return x,
-        BinOp(NaturalTimes, WHNF::NaturalLit(0), _) => {
-            return WHNF::NaturalLit(0)
+        ExprF::BinOp(NaturalPlus, NaturalLit(0), y) => return y,
+        ExprF::BinOp(NaturalPlus, x, NaturalLit(0)) => return x,
+        ExprF::BinOp(NaturalTimes, NaturalLit(0), _) => return NaturalLit(0),
+        ExprF::BinOp(NaturalTimes, _, NaturalLit(0)) => return NaturalLit(0),
+        ExprF::BinOp(NaturalTimes, NaturalLit(1), y) => return y,
+        ExprF::BinOp(NaturalTimes, x, NaturalLit(1)) => return x,
+        ExprF::BinOp(NaturalPlus, NaturalLit(x), NaturalLit(y)) => {
+            return NaturalLit(x + y)
         }
-        BinOp(NaturalTimes, _, WHNF::NaturalLit(0)) => {
-            return WHNF::NaturalLit(0)
-        }
-        BinOp(NaturalTimes, WHNF::NaturalLit(1), y) => return y,
-        BinOp(NaturalTimes, x, WHNF::NaturalLit(1)) => return x,
-        BinOp(NaturalPlus, WHNF::NaturalLit(x), WHNF::NaturalLit(y)) => {
-            return WHNF::NaturalLit(x + y)
-        }
-        BinOp(NaturalTimes, WHNF::NaturalLit(x), WHNF::NaturalLit(y)) => {
-            return WHNF::NaturalLit(x * y)
+        ExprF::BinOp(NaturalTimes, NaturalLit(x), NaturalLit(y)) => {
+            return NaturalLit(x * y)
         }
 
-        BinOp(ListAppend, WHNF::EmptyListLit(_), y) => return y,
-        BinOp(ListAppend, x, WHNF::EmptyListLit(_)) => return x,
-        BinOp(ListAppend, WHNF::NEListLit(mut xs), WHNF::NEListLit(mut ys)) => {
+        ExprF::BinOp(ListAppend, EmptyListLit(_), y) => return y,
+        ExprF::BinOp(ListAppend, x, EmptyListLit(_)) => return x,
+        ExprF::BinOp(ListAppend, NEListLit(mut xs), NEListLit(mut ys)) => {
             xs.append(&mut ys);
-            return WHNF::NEListLit(xs);
+            return NEListLit(xs);
         }
-        BinOp(TextAppend, WHNF::TextLit(mut x), WHNF::TextLit(mut y)) => {
+        ExprF::BinOp(TextAppend, TextLit(mut x), TextLit(mut y)) => {
             x.append(&mut y);
-            return WHNF::TextLit(x);
+            return TextLit(x);
         }
 
-        Field(WHNF::UnionType(ctx, kts), l) => {
-            return WHNF::UnionConstructor(ctx, l, kts)
+        ExprF::Field(UnionType(ctx, kts), l) => {
+            return UnionConstructor(ctx, l, kts)
         }
-        Field(WHNF::RecordLit(mut kvs), l) => {
+        ExprF::Field(RecordLit(mut kvs), l) => {
             match kvs.remove(&l) {
                 Some(r) => return r.normalize(),
                 // Return ownership
-                None => Field(WHNF::RecordLit(kvs), l),
+                None => ExprF::Field(RecordLit(kvs), l),
             }
         }
         // Always simplify `x.{}` to `{}`
-        Projection(_, ls) if ls.is_empty() => {
-            return WHNF::RecordLit(std::collections::BTreeMap::new())
+        ExprF::Projection(_, ls) if ls.is_empty() => {
+            return RecordLit(std::collections::BTreeMap::new())
         }
-        Projection(WHNF::RecordLit(mut kvs), ls) => {
-            return WHNF::RecordLit(
+        ExprF::Projection(RecordLit(mut kvs), ls) => {
+            return RecordLit(
                 ls.into_iter()
                     .filter_map(|l| kvs.remove(&l).map(|x| (l, x)))
                     .collect(),
             )
         }
-        Merge(
-            WHNF::RecordLit(mut handlers),
-            WHNF::UnionConstructor(ctor_ctx, l, kts),
+        ExprF::Merge(
+            RecordLit(mut handlers),
+            UnionConstructor(ctor_ctx, l, kts),
             t,
         ) => match handlers.remove(&l) {
             Some(h) => return h.normalize(),
             // Return ownership
-            None => Merge(
-                WHNF::RecordLit(handlers),
-                WHNF::UnionConstructor(ctor_ctx, l, kts),
+            None => ExprF::Merge(
+                RecordLit(handlers),
+                UnionConstructor(ctor_ctx, l, kts),
                 t,
             ),
         },
-        Merge(
-            WHNF::RecordLit(mut handlers),
-            WHNF::UnionLit(l, v, (kts_ctx, kts)),
+        ExprF::Merge(
+            RecordLit(mut handlers),
+            UnionLit(l, v, (kts_ctx, kts)),
             t,
         ) => match handlers.remove(&l) {
             Some(h) => {
                 let h = h.normalize();
                 let v = v.normalize();
-                return normalize_last_layer(ctx, App(h, v));
+                return normalize_last_layer(ctx, ExprF::App(h, v));
             }
             // Return ownership
-            None => Merge(
-                WHNF::RecordLit(handlers),
-                WHNF::UnionLit(l, v, (kts_ctx, kts)),
+            None => ExprF::Merge(
+                RecordLit(handlers),
+                UnionLit(l, v, (kts_ctx, kts)),
                 t,
             ),
         },
@@ -764,7 +756,7 @@ fn normalize_last_layer(
     };
 
     // Couldn't do anything useful, so just normalize subexpressions
-    WHNF::Expr(rc(expr.map_ref_simple(|e| e.clone().normalize_to_expr())))
+    Expr(rc(expr.map_ref_simple(|e| e.clone().normalize_to_expr())))
 }
 
 /// Reduce an expression to its normal form, performing beta reduction
-- 
cgit v1.2.3


From 9fbc4f6b9a5496c8e41a079484bc9010b25849df Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 21:09:57 +0200
Subject: Cleanup

---
 dhall/src/normalize.rs | 310 +++++++++++++++++++++++--------------------------
 1 file changed, 144 insertions(+), 166 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 26d062b..6d071f2 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -123,7 +123,7 @@ fn apply_builtin(
         (OptionalBuild, [t, g]) => g
             .clone()
             .app(AppliedBuiltin(ctx.clone(), Optional, vec![]).app(t.clone()))
-            .app(SomeConstructorClosure(Now::from_whnf(t.clone())))
+            .app(OptionalSomeClosure(Now::from_whnf(t.clone())))
             .app(EmptyOptionalLit(Now::from_whnf(t.clone()))),
         (OptionalFold, [_, EmptyOptionalLit(_), _, _, nothing]) => {
             nothing.clone()
@@ -225,9 +225,9 @@ enum WHNF {
     Lam(Label, Now, (NormalizationContext, InputSubExpr)),
     AppliedBuiltin(NormalizationContext, Builtin, Vec<WHNF>),
     /// `λ(x: a) -> Some x`
-    SomeConstructorClosure(Now),
-    /// `λ(x : a) -> λ(xs : List a) -> [ x ] # xs
-    /// `λ(xs : List a) -> [ x ] # xs
+    OptionalSomeClosure(Now),
+    /// `λ(x : a) -> λ(xs : List a) -> [ x ] # xs`
+    /// `λ(xs : List a) -> [ x ] # xs`
     ListConsClosure(Now, Option<Now>),
     /// `λ(x : Natural) -> x + 1`
     NaturalSuccClosure,
@@ -275,7 +275,7 @@ impl WHNF {
                 }
                 e.normalize_to_expr()
             }
-            WHNF::SomeConstructorClosure(n) => {
+            WHNF::OptionalSomeClosure(n) => {
                 let a = n.normalize().normalize_to_expr();
                 dhall::subexpr!(λ(x: a) -> Some x)
             }
@@ -410,7 +410,7 @@ impl WHNF {
                     None => WHNF::AppliedBuiltin(ctx, b, args),
                 }
             }
-            (WHNF::SomeConstructorClosure(_), val) => {
+            (WHNF::OptionalSomeClosure(_), val) => {
                 WHNF::NEOptionalLit(Now::from_whnf(val))
             }
             (WHNF::ListConsClosure(t, None), val) => {
@@ -448,8 +448,8 @@ impl WHNF {
                 b,
                 args.into_iter().map(|e| e.shift0(delta, label)).collect(),
             ),
-            WHNF::SomeConstructorClosure(n) => {
-                WHNF::SomeConstructorClosure(n.shift0(delta, label))
+            WHNF::OptionalSomeClosure(n) => {
+                WHNF::OptionalSomeClosure(n.shift0(delta, label))
             }
             WHNF::ListConsClosure(t, v) => WHNF::ListConsClosure(
                 t.shift0(delta, label),
@@ -557,206 +557,184 @@ impl Now {
 
 /// Reduces the imput expression to WHNF. See doc on `WHNF` for details.
 fn normalize_whnf(ctx: NormalizationContext, expr: InputSubExpr) -> WHNF {
-    let expr = match expr.as_ref() {
-        ExprF::Var(v) => return ctx.lookup(&v),
-        ExprF::Annot(x, _) => return normalize_whnf(ctx, x.clone()),
-        ExprF::Note(_, e) => return normalize_whnf(ctx, e.clone()),
+    match expr.as_ref() {
+        ExprF::Var(v) => ctx.lookup(&v),
+        ExprF::Annot(x, _) => normalize_whnf(ctx, x.clone()),
+        ExprF::Note(_, e) => normalize_whnf(ctx, e.clone()),
         // TODO: wasteful to retraverse everything
-        ExprF::Embed(e) => return normalize_whnf(ctx, e.0.embed_absurd()),
+        ExprF::Embed(e) => normalize_whnf(ctx, e.0.embed_absurd()),
         ExprF::Let(x, _, r, b) => {
             let r = normalize_whnf(ctx.clone(), r.clone());
-            return normalize_whnf(ctx.insert(x, r), b.clone());
+            normalize_whnf(ctx.insert(x, r), b.clone())
         }
-        ExprF::Lam(x, t, e) => {
-            return WHNF::Lam(
-                x.clone(),
-                Now::new(ctx.clone(), t.clone()),
-                (ctx, e.clone()),
-            )
-        }
-        ExprF::Builtin(b) => return WHNF::AppliedBuiltin(ctx, *b, vec![]),
-        ExprF::BoolLit(b) => return WHNF::BoolLit(*b),
-        ExprF::NaturalLit(n) => return WHNF::NaturalLit(*n),
+        ExprF::Lam(x, t, e) => WHNF::Lam(
+            x.clone(),
+            Now::new(ctx.clone(), t.clone()),
+            (ctx, e.clone()),
+        ),
+        ExprF::Builtin(b) => WHNF::AppliedBuiltin(ctx, *b, vec![]),
+        ExprF::BoolLit(b) => WHNF::BoolLit(*b),
+        ExprF::NaturalLit(n) => WHNF::NaturalLit(*n),
         ExprF::OldOptionalLit(None, e) => {
-            return WHNF::EmptyOptionalLit(Now::new(ctx, e.clone()))
+            WHNF::EmptyOptionalLit(Now::new(ctx, e.clone()))
         }
         ExprF::OldOptionalLit(Some(e), _) => {
-            return WHNF::NEOptionalLit(Now::new(ctx, e.clone()))
+            WHNF::NEOptionalLit(Now::new(ctx, e.clone()))
         }
         ExprF::EmptyOptionalLit(e) => {
-            return WHNF::EmptyOptionalLit(Now::new(ctx, e.clone()))
+            WHNF::EmptyOptionalLit(Now::new(ctx, e.clone()))
         }
         ExprF::NEOptionalLit(e) => {
-            return WHNF::NEOptionalLit(Now::new(ctx, e.clone()))
-        }
-        ExprF::EmptyListLit(e) => {
-            return WHNF::EmptyListLit(Now::new(ctx, e.clone()))
-        }
-        ExprF::NEListLit(elts) => {
-            return WHNF::NEListLit(
-                elts.iter()
-                    .map(|e| Now::new(ctx.clone(), e.clone()))
-                    .collect(),
-            )
-        }
-        ExprF::RecordLit(kvs) => {
-            return WHNF::RecordLit(
-                kvs.iter()
-                    .map(|(k, e)| (k.clone(), Now::new(ctx.clone(), e.clone())))
-                    .collect(),
-            )
-        }
-        ExprF::UnionType(kvs) => return WHNF::UnionType(ctx, kvs.clone()),
-        ExprF::UnionLit(l, x, kts) => {
-            return WHNF::UnionLit(
-                l.clone(),
-                Now::new(ctx.clone(), x.clone()),
-                (ctx, kts.clone()),
-            )
-        }
-        ExprF::TextLit(elts) => {
-            return WHNF::TextLit(
-                elts.iter()
-                    .map(|contents| {
-                        use InterpolatedTextContents::{Expr, Text};
-                        match contents {
-                            Expr(n) => Expr(Now::new(ctx.clone(), n.clone())),
-                            Text(s) => Text(s.clone()),
-                        }
-                    })
-                    .collect(),
-            )
+            WHNF::NEOptionalLit(Now::new(ctx, e.clone()))
         }
+        ExprF::EmptyListLit(e) => WHNF::EmptyListLit(Now::new(ctx, e.clone())),
+        ExprF::NEListLit(elts) => WHNF::NEListLit(
+            elts.iter()
+                .map(|e| Now::new(ctx.clone(), e.clone()))
+                .collect(),
+        ),
+        ExprF::RecordLit(kvs) => WHNF::RecordLit(
+            kvs.iter()
+                .map(|(k, e)| (k.clone(), Now::new(ctx.clone(), e.clone())))
+                .collect(),
+        ),
+        ExprF::UnionType(kvs) => WHNF::UnionType(ctx, kvs.clone()),
+        ExprF::UnionLit(l, x, kts) => WHNF::UnionLit(
+            l.clone(),
+            Now::new(ctx.clone(), x.clone()),
+            (ctx, kts.clone()),
+        ),
+        ExprF::TextLit(elts) => WHNF::TextLit(
+            elts.iter()
+                .map(|contents| {
+                    use InterpolatedTextContents::{Expr, Text};
+                    match contents {
+                        Expr(n) => Expr(Now::new(ctx.clone(), n.clone())),
+                        Text(s) => Text(s.clone()),
+                    }
+                })
+                .collect(),
+        ),
         ExprF::BoolIf(b, e1, e2) => {
             let b = normalize_whnf(ctx.clone(), b.clone());
             match b {
-                WHNF::BoolLit(true) => return normalize_whnf(ctx, e1.clone()),
-                WHNF::BoolLit(false) => return normalize_whnf(ctx, e2.clone()),
-                _ => expr,
+                WHNF::BoolLit(true) => normalize_whnf(ctx, e1.clone()),
+                WHNF::BoolLit(false) => normalize_whnf(ctx, e2.clone()),
+                _ => normalize_last_layer(ExprF::BoolIf(
+                    b,
+                    normalize_whnf(ctx.clone(), e1.clone()),
+                    normalize_whnf(ctx, e2.clone()),
+                )),
             }
         }
-        _ => expr,
-    };
-
-    // Recursively normalize all subexpressions
-    let expr: ExprF<WHNF, Label, X, X> =
-        expr.as_ref().map_ref_with_special_handling_of_binders(
-            |e| normalize_whnf(ctx.clone(), e.clone()),
-            |x, e| normalize_whnf(ctx.skip(x), e.clone()),
-            X::clone,
-            |_| unreachable!(),
-            Label::clone,
-        );
+        expr => {
+            // Recursively normalize subexpressions
+            let expr: ExprF<WHNF, Label, X, X> = expr
+                .map_ref_with_special_handling_of_binders(
+                    |e| normalize_whnf(ctx.clone(), e.clone()),
+                    |x, e| normalize_whnf(ctx.skip(x), e.clone()),
+                    X::clone,
+                    |_| unreachable!(),
+                    Label::clone,
+                );
 
-    normalize_last_layer(ctx, expr)
+            normalize_last_layer(expr)
+        }
+    }
 }
 
 /// When all sub-expressions have been (partially) normalized, eval the remaining toplevel layer.
-fn normalize_last_layer(
-    ctx: NormalizationContext,
-    expr: ExprF<WHNF, Label, X, X>,
-) -> WHNF {
+fn normalize_last_layer(expr: ExprF<WHNF, Label, X, X>) -> WHNF {
     use dhall_core::BinOp::*;
     use WHNF::*;
 
-    let expr = match expr {
-        ExprF::App(v, a) => return v.app(a),
+    match expr {
+        ExprF::App(v, a) => v.app(a),
 
-        ExprF::BinOp(BoolAnd, BoolLit(true), y) => return y,
-        ExprF::BinOp(BoolAnd, x, BoolLit(true)) => return x,
-        ExprF::BinOp(BoolAnd, BoolLit(false), _) => return BoolLit(false),
-        ExprF::BinOp(BoolAnd, _, BoolLit(false)) => return BoolLit(false),
-        ExprF::BinOp(BoolOr, BoolLit(true), _) => return BoolLit(true),
-        ExprF::BinOp(BoolOr, _, BoolLit(true)) => return BoolLit(true),
-        ExprF::BinOp(BoolOr, BoolLit(false), y) => return y,
-        ExprF::BinOp(BoolOr, x, BoolLit(false)) => return x,
-        ExprF::BinOp(BoolEQ, BoolLit(true), y) => return y,
-        ExprF::BinOp(BoolEQ, x, BoolLit(true)) => return x,
-        ExprF::BinOp(BoolNE, BoolLit(false), y) => return y,
-        ExprF::BinOp(BoolNE, x, BoolLit(false)) => return x,
-        ExprF::BinOp(BoolEQ, BoolLit(x), BoolLit(y)) => return BoolLit(x == y),
-        ExprF::BinOp(BoolNE, BoolLit(x), BoolLit(y)) => return BoolLit(x != y),
+        ExprF::BinOp(BoolAnd, BoolLit(true), y) => y,
+        ExprF::BinOp(BoolAnd, x, BoolLit(true)) => x,
+        ExprF::BinOp(BoolAnd, BoolLit(false), _) => BoolLit(false),
+        ExprF::BinOp(BoolAnd, _, BoolLit(false)) => BoolLit(false),
+        ExprF::BinOp(BoolOr, BoolLit(true), _) => BoolLit(true),
+        ExprF::BinOp(BoolOr, _, BoolLit(true)) => BoolLit(true),
+        ExprF::BinOp(BoolOr, BoolLit(false), y) => y,
+        ExprF::BinOp(BoolOr, x, BoolLit(false)) => x,
+        ExprF::BinOp(BoolEQ, BoolLit(true), y) => y,
+        ExprF::BinOp(BoolEQ, x, BoolLit(true)) => x,
+        ExprF::BinOp(BoolNE, BoolLit(false), y) => y,
+        ExprF::BinOp(BoolNE, x, BoolLit(false)) => x,
+        ExprF::BinOp(BoolEQ, BoolLit(x), BoolLit(y)) => BoolLit(x == y),
+        ExprF::BinOp(BoolNE, BoolLit(x), BoolLit(y)) => BoolLit(x != y),
 
-        ExprF::BinOp(NaturalPlus, NaturalLit(0), y) => return y,
-        ExprF::BinOp(NaturalPlus, x, NaturalLit(0)) => return x,
-        ExprF::BinOp(NaturalTimes, NaturalLit(0), _) => return NaturalLit(0),
-        ExprF::BinOp(NaturalTimes, _, NaturalLit(0)) => return NaturalLit(0),
-        ExprF::BinOp(NaturalTimes, NaturalLit(1), y) => return y,
-        ExprF::BinOp(NaturalTimes, x, NaturalLit(1)) => return x,
+        ExprF::BinOp(NaturalPlus, NaturalLit(0), y) => y,
+        ExprF::BinOp(NaturalPlus, x, NaturalLit(0)) => x,
+        ExprF::BinOp(NaturalTimes, NaturalLit(0), _) => NaturalLit(0),
+        ExprF::BinOp(NaturalTimes, _, NaturalLit(0)) => NaturalLit(0),
+        ExprF::BinOp(NaturalTimes, NaturalLit(1), y) => y,
+        ExprF::BinOp(NaturalTimes, x, NaturalLit(1)) => x,
         ExprF::BinOp(NaturalPlus, NaturalLit(x), NaturalLit(y)) => {
-            return NaturalLit(x + y)
+            NaturalLit(x + y)
         }
         ExprF::BinOp(NaturalTimes, NaturalLit(x), NaturalLit(y)) => {
-            return NaturalLit(x * y)
+            NaturalLit(x * y)
         }
 
-        ExprF::BinOp(ListAppend, EmptyListLit(_), y) => return y,
-        ExprF::BinOp(ListAppend, x, EmptyListLit(_)) => return x,
+        ExprF::BinOp(ListAppend, EmptyListLit(_), y) => y,
+        ExprF::BinOp(ListAppend, x, EmptyListLit(_)) => x,
         ExprF::BinOp(ListAppend, NEListLit(mut xs), NEListLit(mut ys)) => {
             xs.append(&mut ys);
-            return NEListLit(xs);
+            NEListLit(xs)
         }
         ExprF::BinOp(TextAppend, TextLit(mut x), TextLit(mut y)) => {
             x.append(&mut y);
-            return TextLit(x);
+            TextLit(x)
         }
 
-        ExprF::Field(UnionType(ctx, kts), l) => {
-            return UnionConstructor(ctx, l, kts)
-        }
-        ExprF::Field(RecordLit(mut kvs), l) => {
-            match kvs.remove(&l) {
-                Some(r) => return r.normalize(),
-                // Return ownership
-                None => ExprF::Field(RecordLit(kvs), l),
+        ExprF::Field(UnionType(ctx, kts), l) => UnionConstructor(ctx, l, kts),
+        ExprF::Field(RecordLit(mut kvs), l) => match kvs.remove(&l) {
+            Some(r) => r.normalize(),
+            None => {
+                // Couldn't do anything useful, so just normalize subexpressions
+                Expr(rc(ExprF::Field(RecordLit(kvs).normalize_to_expr(), l)))
             }
-        }
-        // Always simplify `x.{}` to `{}`
+        },
         ExprF::Projection(_, ls) if ls.is_empty() => {
-            return RecordLit(std::collections::BTreeMap::new())
+            RecordLit(std::collections::BTreeMap::new())
         }
-        ExprF::Projection(RecordLit(mut kvs), ls) => {
-            return RecordLit(
-                ls.into_iter()
-                    .filter_map(|l| kvs.remove(&l).map(|x| (l, x)))
-                    .collect(),
-            )
+        ExprF::Projection(RecordLit(mut kvs), ls) => RecordLit(
+            ls.into_iter()
+                .filter_map(|l| kvs.remove(&l).map(|x| (l, x)))
+                .collect(),
+        ),
+        ExprF::Merge(RecordLit(mut handlers), e, t) => {
+            let e = match e {
+                UnionConstructor(ctor_ctx, l, kts) => match handlers.remove(&l)
+                {
+                    Some(h) => return h.normalize(),
+                    None => UnionConstructor(ctor_ctx, l, kts),
+                },
+                UnionLit(l, v, (kts_ctx, kts)) => match handlers.remove(&l) {
+                    Some(h) => {
+                        let h = h.normalize();
+                        let v = v.normalize();
+                        return h.app(v);
+                    }
+                    None => UnionLit(l, v, (kts_ctx, kts)),
+                },
+                e => e,
+            };
+            // Couldn't do anything useful, so just normalize subexpressions
+            Expr(rc(ExprF::Merge(
+                RecordLit(handlers).normalize_to_expr(),
+                e.normalize_to_expr(),
+                t.map(WHNF::normalize_to_expr),
+            )))
         }
-        ExprF::Merge(
-            RecordLit(mut handlers),
-            UnionConstructor(ctor_ctx, l, kts),
-            t,
-        ) => match handlers.remove(&l) {
-            Some(h) => return h.normalize(),
-            // Return ownership
-            None => ExprF::Merge(
-                RecordLit(handlers),
-                UnionConstructor(ctor_ctx, l, kts),
-                t,
-            ),
-        },
-        ExprF::Merge(
-            RecordLit(mut handlers),
-            UnionLit(l, v, (kts_ctx, kts)),
-            t,
-        ) => match handlers.remove(&l) {
-            Some(h) => {
-                let h = h.normalize();
-                let v = v.normalize();
-                return normalize_last_layer(ctx, ExprF::App(h, v));
-            }
-            // Return ownership
-            None => ExprF::Merge(
-                RecordLit(handlers),
-                UnionLit(l, v, (kts_ctx, kts)),
-                t,
-            ),
-        },
-        expr => expr,
-    };
-
-    // Couldn't do anything useful, so just normalize subexpressions
-    Expr(rc(expr.map_ref_simple(|e| e.clone().normalize_to_expr())))
+        // Couldn't do anything useful, so just normalize subexpressions
+        expr => {
+            Expr(rc(expr.map_ref_simple(|e| e.clone().normalize_to_expr())))
+        }
+    }
 }
 
 /// Reduce an expression to its normal form, performing beta reduction
-- 
cgit v1.2.3


From 0c981c548db098b0842b79faecfba93f32a1b589 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 22:11:37 +0200
Subject: Avoid a lot of unnecessary cloning in apply_builtin

---
 dhall/src/normalize.rs | 309 +++++++++++++++++++++++++++++--------------------
 1 file changed, 183 insertions(+), 126 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 6d071f2..ae27ab8 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -32,133 +32,193 @@ impl<'a> Typed<'a> {
 fn apply_builtin(
     ctx: NormalizationContext,
     b: Builtin,
-    args: &[WHNF],
-) -> Option<WHNF> {
+    args: Vec<WHNF>,
+) -> WHNF {
     use dhall_core::Builtin::*;
     use WHNF::*;
 
-    let ret = match (b, args) {
-        (OptionalNone, [t]) => EmptyOptionalLit(Now::from_whnf(t.clone())),
-        (NaturalIsZero, [NaturalLit(n)]) => BoolLit(*n == 0),
-        (NaturalEven, [NaturalLit(n)]) => BoolLit(*n % 2 == 0),
-        (NaturalOdd, [NaturalLit(n)]) => BoolLit(*n % 2 != 0),
-        (NaturalToInteger, [NaturalLit(n)]) => IntegerLit(*n as isize),
-        (NaturalShow, [NaturalLit(n)]) => {
-            TextLit(vec![InterpolatedTextContents::Text(n.to_string())])
-        }
-        (ListLength, [_, EmptyListLit(_)]) => NaturalLit(0),
-        (ListLength, [_, NEListLit(xs)]) => NaturalLit(xs.len()),
-        (ListHead, [_, EmptyListLit(n)]) => EmptyOptionalLit(n.clone()),
-        (ListHead, [_, NEListLit(xs)]) => {
-            NEOptionalLit(xs.first().unwrap().clone())
-        }
-        (ListLast, [_, EmptyListLit(n)]) => EmptyOptionalLit(n.clone()),
-        (ListLast, [_, NEListLit(xs)]) => {
-            NEOptionalLit(xs.last().unwrap().clone())
-        }
-        (ListReverse, [_, EmptyListLit(n)]) => EmptyListLit(n.clone()),
-        (ListReverse, [_, NEListLit(xs)]) => {
-            let xs = xs.iter().cloned().rev().collect();
-            NEListLit(xs)
-        }
-        (ListIndexed, [_, EmptyListLit(t)]) => {
-            let mut kts = BTreeMap::new();
-            kts.insert(
-                "index".into(),
-                Now::from_whnf(AppliedBuiltin(ctx, Natural, vec![])),
-            );
-            kts.insert("value".into(), t.clone());
-            EmptyListLit(Now::from_whnf(RecordType(kts)))
-        }
-        (ListIndexed, [_, NEListLit(xs)]) => {
-            let xs = xs
-                .iter()
-                .cloned()
-                .enumerate()
-                .map(|(i, e)| {
-                    let i = NaturalLit(i);
-                    let mut kvs = BTreeMap::new();
-                    kvs.insert("index".into(), Now::from_whnf(i));
-                    kvs.insert("value".into(), e);
-                    Now::from_whnf(RecordLit(kvs))
-                })
-                .collect();
-            NEListLit(xs)
-        }
-        // fold/build fusion
-        (ListBuild, [_, WHNF::AppliedBuiltin(_, ListFold, args)])
-            if args.len() == 2 =>
-        {
-            args.get(1).unwrap().clone()
-        }
-        (ListFold, [_, WHNF::AppliedBuiltin(_, ListBuild, args)])
-            if args.len() == 2 =>
-        {
-            args.get(1).unwrap().clone()
-        }
-        (ListBuild, [t, g]) => g
-            .clone()
-            .app(AppliedBuiltin(ctx.clone(), List, vec![]).app(t.clone()))
-            .app(ListConsClosure(Now::from_whnf(t.clone()), None))
-            .app(EmptyListLit(Now::from_whnf(t.clone()))),
-        (ListFold, [_, EmptyListLit(_), _, _, nil]) => nil.clone(),
-        (ListFold, [_, NEListLit(xs), _, cons, nil]) => {
-            let mut v = nil.clone();
-            for x in xs.iter().rev() {
-                v = cons.clone().app(x.clone().normalize()).app(v);
+    let ret = match b {
+        OptionalNone => improved_slice_patterns::match_vec!(args;
+            [t] => EmptyOptionalLit(Now::from_whnf(t)),
+        ),
+        NaturalIsZero => improved_slice_patterns::match_vec!(args;
+            [NaturalLit(n)] => BoolLit(n == 0),
+        ),
+        NaturalEven => improved_slice_patterns::match_vec!(args;
+            [NaturalLit(n)] => BoolLit(n % 2 == 0),
+        ),
+        NaturalOdd => improved_slice_patterns::match_vec!(args;
+            [NaturalLit(n)] => BoolLit(n % 2 != 0),
+        ),
+        NaturalToInteger => improved_slice_patterns::match_vec!(args;
+            [NaturalLit(n)] => IntegerLit(n as isize),
+        ),
+        NaturalShow => improved_slice_patterns::match_vec!(args;
+            [NaturalLit(n)] => {
+                TextLit(vec![InterpolatedTextContents::Text(n.to_string())])
             }
-            v
-        }
-        // fold/build fusion
-        (OptionalBuild, [_, WHNF::AppliedBuiltin(_, OptionalFold, args)])
-            if args.len() == 2 =>
-        {
-            args.get(1).unwrap().clone()
-        }
-        (OptionalFold, [_, WHNF::AppliedBuiltin(_, OptionalBuild, args)])
-            if args.len() == 2 =>
-        {
-            args.get(1).unwrap().clone()
-        }
-        (OptionalBuild, [t, g]) => g
-            .clone()
-            .app(AppliedBuiltin(ctx.clone(), Optional, vec![]).app(t.clone()))
-            .app(OptionalSomeClosure(Now::from_whnf(t.clone())))
-            .app(EmptyOptionalLit(Now::from_whnf(t.clone()))),
-        (OptionalFold, [_, EmptyOptionalLit(_), _, _, nothing]) => {
-            nothing.clone()
-        }
-        (OptionalFold, [_, NEOptionalLit(x), _, just, _]) => {
-            just.clone().app(x.clone().normalize())
-        }
-        // fold/build fusion
-        (NaturalBuild, [WHNF::AppliedBuiltin(_, NaturalFold, args)])
-            if args.len() == 1 =>
-        {
-            args.get(0).unwrap().clone()
-        }
-        (NaturalFold, [WHNF::AppliedBuiltin(_, NaturalBuild, args)])
-            if args.len() == 1 =>
-        {
-            args.get(0).unwrap().clone()
-        }
-        (NaturalBuild, [g]) => g
-            .clone()
-            .app(AppliedBuiltin(ctx.clone(), Natural, vec![]))
-            .app(NaturalSuccClosure)
-            .app(NaturalLit(0)),
-        (NaturalFold, [NaturalLit(0), _, _, zero]) => zero.clone(),
-        (NaturalFold, [NaturalLit(n), t, succ, zero]) => {
-            let fold = AppliedBuiltin(ctx, NaturalFold, vec![])
-                .app(NaturalLit(n - 1))
-                .app(t.clone())
-                .app(succ.clone())
-                .app(zero.clone());
-            succ.clone().app(fold)
-        }
-        _ => return None,
+        ),
+        ListLength => improved_slice_patterns::match_vec!(args;
+           [_, EmptyListLit(_)] => NaturalLit(0),
+           [_, NEListLit(xs)] => NaturalLit(xs.len()),
+        ),
+        ListHead => improved_slice_patterns::match_vec!(args;
+            [_, EmptyListLit(n)] => EmptyOptionalLit(n),
+            [_, NEListLit(xs)] => {
+                NEOptionalLit(xs.into_iter().next().unwrap())
+            }
+        ),
+        ListLast => improved_slice_patterns::match_vec!(args;
+            [_, EmptyListLit(n)] => EmptyOptionalLit(n),
+            [_, NEListLit(xs)] => {
+                NEOptionalLit(xs.into_iter().rev().next().unwrap())
+            }
+        ),
+        ListReverse => improved_slice_patterns::match_vec!(args;
+            [_, EmptyListLit(n)] => EmptyListLit(n),
+            [_, NEListLit(xs)] => {
+                let mut xs = xs;
+                xs.reverse();
+                NEListLit(xs)
+            }
+        ),
+        ListIndexed => improved_slice_patterns::match_vec!(args;
+            [_, EmptyListLit(t)] => {
+                let mut kts = BTreeMap::new();
+                kts.insert(
+                    "index".into(),
+                    Now::from_whnf(
+                        AppliedBuiltin(ctx.clone(), Natural, vec![])
+                    ),
+                );
+                kts.insert("value".into(), t);
+                EmptyListLit(Now::from_whnf(RecordType(kts)))
+            },
+            [_, NEListLit(xs)] => {
+                let xs = xs
+                    .into_iter()
+                    .enumerate()
+                    .map(|(i, e)| {
+                        let i = NaturalLit(i);
+                        let mut kvs = BTreeMap::new();
+                        kvs.insert("index".into(), Now::from_whnf(i));
+                        kvs.insert("value".into(), e);
+                        Now::from_whnf(RecordLit(kvs))
+                    })
+                    .collect();
+                NEListLit(xs)
+            }
+        ),
+        ListBuild => improved_slice_patterns::match_vec!(args;
+            // fold/build fusion
+            [_, WHNF::AppliedBuiltin(_, ListFold, args)] => {
+                let mut args = args;
+                if args.len() >= 2 {
+                    args.remove(1)
+                } else {
+                    // Do we really need to handle this case ?
+                    unimplemented!()
+                }
+            },
+            [t, g] => g
+                .app(AppliedBuiltin(ctx.clone(), List, vec![]).app(t.clone()))
+                .app(ListConsClosure(Now::from_whnf(t.clone()), None))
+                .app(EmptyListLit(Now::from_whnf(t))),
+        ),
+        ListFold => improved_slice_patterns::match_vec!(args;
+            // fold/build fusion
+            [_, WHNF::AppliedBuiltin(_, ListBuild, args)] => {
+                let mut args = args;
+                if args.len() >= 2 {
+                    args.remove(1)
+                } else {
+                    unimplemented!()
+                }
+            },
+            [_, EmptyListLit(_), _, _, nil] => nil,
+            [_, NEListLit(xs), _, cons, nil] => {
+                let mut v = nil;
+                for x in xs.into_iter().rev() {
+                    v = cons.clone().app(x.normalize()).app(v);
+                }
+                v
+            }
+        ),
+        OptionalBuild => improved_slice_patterns::match_vec!(args;
+            // fold/build fusion
+            [_, WHNF::AppliedBuiltin(_, OptionalFold, args)] => {
+                let mut args = args;
+                if args.len() >= 2 {
+                    args.remove(1)
+                } else {
+                    unimplemented!()
+                }
+            },
+            [t, g] => g
+                .app(AppliedBuiltin(ctx.clone(), Optional, vec![])
+                    .app(t.clone()))
+                .app(OptionalSomeClosure(Now::from_whnf(t.clone())))
+                .app(EmptyOptionalLit(Now::from_whnf(t))),
+        ),
+        OptionalFold => improved_slice_patterns::match_vec!(args;
+            // fold/build fusion
+            [_, WHNF::AppliedBuiltin(_, OptionalBuild, args)] => {
+                let mut args = args;
+                if args.len() >= 2 {
+                    args.remove(1)
+                } else {
+                    unimplemented!()
+                }
+            },
+            [_, EmptyOptionalLit(_), _, _, nothing] => {
+                nothing
+            },
+            [_, NEOptionalLit(x), _, just, _] => {
+                just.app(x.normalize())
+            }
+        ),
+        NaturalBuild => improved_slice_patterns::match_vec!(args;
+            // fold/build fusion
+            [WHNF::AppliedBuiltin(_, NaturalFold, args)] => {
+                let mut args = args;
+                if args.len() >= 1 {
+                    args.remove(0)
+                } else {
+                    unimplemented!()
+                }
+            },
+            [g] => g
+                .app(AppliedBuiltin(ctx.clone(), Natural, vec![]))
+                .app(NaturalSuccClosure)
+                .app(NaturalLit(0)),
+        ),
+        NaturalFold => improved_slice_patterns::match_vec!(args;
+            // fold/build fusion
+            [WHNF::AppliedBuiltin(_, NaturalBuild, args)] => {
+                let mut args = args;
+                if args.len() >= 1 {
+                    args.remove(0)
+                } else {
+                    unimplemented!()
+                }
+            },
+            [NaturalLit(0), _, _, zero] => zero,
+            [NaturalLit(n), t, succ, zero] => {
+                let fold = AppliedBuiltin(ctx.clone(), NaturalFold, vec![])
+                    .app(NaturalLit(n - 1))
+                    .app(t)
+                    .app(succ.clone())
+                    .app(zero);
+                succ.app(fold)
+            },
+        ),
+        _ => Err(args),
     };
-    Some(ret)
+
+    match ret {
+        Ok(x) => x,
+        Err(args) => AppliedBuiltin(ctx, b, args),
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -405,10 +465,7 @@ impl WHNF {
             }
             (WHNF::AppliedBuiltin(ctx, b, mut args), val) => {
                 args.push(val);
-                match apply_builtin(ctx.clone(), b, &args) {
-                    Some(v) => v,
-                    None => WHNF::AppliedBuiltin(ctx, b, args),
-                }
+                apply_builtin(ctx, b, args)
             }
             (WHNF::OptionalSomeClosure(_), val) => {
                 WHNF::NEOptionalLit(Now::from_whnf(val))
-- 
cgit v1.2.3


From 6d56f304ed20620f150303998d041fe46411550d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 22:19:21 +0200
Subject: AppliedBuiltin does not need a context

---
 dhall/src/normalize.rs | 48 +++++++++++++++++++++++-------------------------
 1 file changed, 23 insertions(+), 25 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index ae27ab8..71c8d31 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -29,11 +29,7 @@ impl<'a> Typed<'a> {
     }
 }
 
-fn apply_builtin(
-    ctx: NormalizationContext,
-    b: Builtin,
-    args: Vec<WHNF>,
-) -> WHNF {
+fn apply_builtin(b: Builtin, args: Vec<WHNF>) -> WHNF {
     use dhall_core::Builtin::*;
     use WHNF::*;
 
@@ -88,7 +84,7 @@ fn apply_builtin(
                 kts.insert(
                     "index".into(),
                     Now::from_whnf(
-                        AppliedBuiltin(ctx.clone(), Natural, vec![])
+                        WHNF::from_builtin(Natural)
                     ),
                 );
                 kts.insert("value".into(), t);
@@ -111,7 +107,7 @@ fn apply_builtin(
         ),
         ListBuild => improved_slice_patterns::match_vec!(args;
             // fold/build fusion
-            [_, WHNF::AppliedBuiltin(_, ListFold, args)] => {
+            [_, WHNF::AppliedBuiltin(ListFold, args)] => {
                 let mut args = args;
                 if args.len() >= 2 {
                     args.remove(1)
@@ -121,13 +117,13 @@ fn apply_builtin(
                 }
             },
             [t, g] => g
-                .app(AppliedBuiltin(ctx.clone(), List, vec![]).app(t.clone()))
+                .app(WHNF::from_builtin(List).app(t.clone()))
                 .app(ListConsClosure(Now::from_whnf(t.clone()), None))
                 .app(EmptyListLit(Now::from_whnf(t))),
         ),
         ListFold => improved_slice_patterns::match_vec!(args;
             // fold/build fusion
-            [_, WHNF::AppliedBuiltin(_, ListBuild, args)] => {
+            [_, WHNF::AppliedBuiltin(ListBuild, args)] => {
                 let mut args = args;
                 if args.len() >= 2 {
                     args.remove(1)
@@ -146,7 +142,7 @@ fn apply_builtin(
         ),
         OptionalBuild => improved_slice_patterns::match_vec!(args;
             // fold/build fusion
-            [_, WHNF::AppliedBuiltin(_, OptionalFold, args)] => {
+            [_, WHNF::AppliedBuiltin(OptionalFold, args)] => {
                 let mut args = args;
                 if args.len() >= 2 {
                     args.remove(1)
@@ -155,14 +151,13 @@ fn apply_builtin(
                 }
             },
             [t, g] => g
-                .app(AppliedBuiltin(ctx.clone(), Optional, vec![])
-                    .app(t.clone()))
+                .app(WHNF::from_builtin(Optional).app(t.clone()))
                 .app(OptionalSomeClosure(Now::from_whnf(t.clone())))
                 .app(EmptyOptionalLit(Now::from_whnf(t))),
         ),
         OptionalFold => improved_slice_patterns::match_vec!(args;
             // fold/build fusion
-            [_, WHNF::AppliedBuiltin(_, OptionalBuild, args)] => {
+            [_, WHNF::AppliedBuiltin(OptionalBuild, args)] => {
                 let mut args = args;
                 if args.len() >= 2 {
                     args.remove(1)
@@ -179,7 +174,7 @@ fn apply_builtin(
         ),
         NaturalBuild => improved_slice_patterns::match_vec!(args;
             // fold/build fusion
-            [WHNF::AppliedBuiltin(_, NaturalFold, args)] => {
+            [WHNF::AppliedBuiltin(NaturalFold, args)] => {
                 let mut args = args;
                 if args.len() >= 1 {
                     args.remove(0)
@@ -188,13 +183,13 @@ fn apply_builtin(
                 }
             },
             [g] => g
-                .app(AppliedBuiltin(ctx.clone(), Natural, vec![]))
+                .app(WHNF::from_builtin(Natural))
                 .app(NaturalSuccClosure)
                 .app(NaturalLit(0)),
         ),
         NaturalFold => improved_slice_patterns::match_vec!(args;
             // fold/build fusion
-            [WHNF::AppliedBuiltin(_, NaturalBuild, args)] => {
+            [WHNF::AppliedBuiltin(NaturalBuild, args)] => {
                 let mut args = args;
                 if args.len() >= 1 {
                     args.remove(0)
@@ -204,7 +199,7 @@ fn apply_builtin(
             },
             [NaturalLit(0), _, _, zero] => zero,
             [NaturalLit(n), t, succ, zero] => {
-                let fold = AppliedBuiltin(ctx.clone(), NaturalFold, vec![])
+                let fold = WHNF::from_builtin(NaturalFold)
                     .app(NaturalLit(n - 1))
                     .app(t)
                     .app(succ.clone())
@@ -217,7 +212,7 @@ fn apply_builtin(
 
     match ret {
         Ok(x) => x,
-        Err(args) => AppliedBuiltin(ctx, b, args),
+        Err(args) => AppliedBuiltin(b, args),
     }
 }
 
@@ -283,7 +278,7 @@ impl NormalizationContext {
 enum WHNF {
     /// Closures
     Lam(Label, Now, (NormalizationContext, InputSubExpr)),
-    AppliedBuiltin(NormalizationContext, Builtin, Vec<WHNF>),
+    AppliedBuiltin(Builtin, Vec<WHNF>),
     /// `λ(x: a) -> Some x`
     OptionalSomeClosure(Now),
     /// `λ(x : a) -> λ(xs : List a) -> [ x ] # xs`
@@ -328,7 +323,7 @@ impl WHNF {
                     normalize_whnf(ctx2, e).normalize_to_expr(),
                 ))
             }
-            WHNF::AppliedBuiltin(_ctx, b, args) => {
+            WHNF::AppliedBuiltin(b, args) => {
                 let mut e = WHNF::Expr(rc(ExprF::Builtin(b)));
                 for v in args {
                     e = e.app(v);
@@ -463,9 +458,9 @@ impl WHNF {
                 let ctx2 = ctx.insert(&x, val);
                 normalize_whnf(ctx2, e)
             }
-            (WHNF::AppliedBuiltin(ctx, b, mut args), val) => {
+            (WHNF::AppliedBuiltin(b, mut args), val) => {
                 args.push(val);
-                apply_builtin(ctx, b, args)
+                apply_builtin(b, args)
             }
             (WHNF::OptionalSomeClosure(_), val) => {
                 WHNF::NEOptionalLit(Now::from_whnf(val))
@@ -493,6 +488,10 @@ impl WHNF {
         }
     }
 
+    fn from_builtin(b: Builtin) -> WHNF {
+        WHNF::AppliedBuiltin(b, vec![])
+    }
+
     fn shift0(self, delta: isize, label: &Label) -> Self {
         match self {
             WHNF::Lam(x, t, (ctx, e)) => WHNF::Lam(
@@ -500,8 +499,7 @@ impl WHNF {
                 t.shift0(delta, label),
                 (ctx, shift(delta, &V(label.clone(), 1), &e)),
             ),
-            WHNF::AppliedBuiltin(ctx, b, args) => WHNF::AppliedBuiltin(
-                ctx,
+            WHNF::AppliedBuiltin(b, args) => WHNF::AppliedBuiltin(
                 b,
                 args.into_iter().map(|e| e.shift0(delta, label)).collect(),
             ),
@@ -629,7 +627,7 @@ fn normalize_whnf(ctx: NormalizationContext, expr: InputSubExpr) -> WHNF {
             Now::new(ctx.clone(), t.clone()),
             (ctx, e.clone()),
         ),
-        ExprF::Builtin(b) => WHNF::AppliedBuiltin(ctx, *b, vec![]),
+        ExprF::Builtin(b) => WHNF::AppliedBuiltin(*b, vec![]),
         ExprF::BoolLit(b) => WHNF::BoolLit(*b),
         ExprF::NaturalLit(n) => WHNF::NaturalLit(*n),
         ExprF::OldOptionalLit(None, e) => {
-- 
cgit v1.2.3


From f2faf1f32fb12a3d3285b3959e3805796ac96ea1 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 22:30:15 +0200
Subject: Tweaks

---
 dhall/src/normalize.rs | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 71c8d31..f6ec09c 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -262,10 +262,10 @@ impl NormalizationContext {
 
 /// A semantic value. This is partially redundant with `dhall_core::Expr`, on purpose. `Expr` should
 /// be limited to syntactic expressions: either written by the user or meant to be printed.
-/// The rule is the following: we must _not_ construct values of type `Expr` while normalizing or
-/// typechecking, but only construct `WHNF`s.
+/// The rule is the following: we must _not_ construct values of type `Expr` while normalizing,
+/// but only construct `WHNF`s.
 ///
-/// WHNFs usually store subexpressions unnormalized, to enable lazy normalization. They approximate
+/// WHNFs store subexpressions unnormalized, to enable lazy normalization. They approximate
 /// what's called Weak Head Normal-Form (WHNF). This means that the expression is normalized as
 /// little as possible, but just enough to know the first constructor of the normal form. This is
 /// identical to full normalization for simple types like integers, but for e.g. a record literal
@@ -471,8 +471,9 @@ impl WHNF {
             (WHNF::ListConsClosure(_, Some(x)), WHNF::EmptyListLit(_)) => {
                 WHNF::NEListLit(vec![x])
             }
-            (WHNF::ListConsClosure(_, Some(x)), WHNF::NEListLit(xs)) => {
-                WHNF::NEListLit(std::iter::once(x).chain(xs).collect())
+            (WHNF::ListConsClosure(_, Some(x)), WHNF::NEListLit(mut xs)) => {
+                xs.insert(0, x);
+                WHNF::NEListLit(xs)
             }
             (WHNF::NaturalSuccClosure, WHNF::NaturalLit(n)) => {
                 WHNF::NaturalLit(n + 1)
-- 
cgit v1.2.3


From 6a763de51fc01067e87a5abc1261e20e32c13483 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 22:49:46 +0200
Subject: shift by mutable ref to avoid reallocations

---
 dhall/src/normalize.rs | 151 +++++++++++++++++++++++--------------------------
 1 file changed, 71 insertions(+), 80 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index f6ec09c..ec25010 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -29,6 +29,16 @@ impl<'a> Typed<'a> {
     }
 }
 
+fn shift0_mut<N, E>(delta: isize, label: &Label, in_expr: &mut SubExpr<N, E>) {
+    let new_expr = shift0(delta, label, &in_expr);
+    std::mem::replace(in_expr, new_expr);
+}
+
+fn shift_mut<N, E>(delta: isize, var: &V<Label>, in_expr: &mut SubExpr<N, E>) {
+    let new_expr = shift(delta, var, &in_expr);
+    std::mem::replace(in_expr, new_expr);
+}
+
 fn apply_builtin(b: Builtin, args: Vec<WHNF>) -> WHNF {
     use dhall_core::Builtin::*;
     use WHNF::*;
@@ -240,7 +250,11 @@ impl NormalizationContext {
                 .map(|l, e| {
                     use EnvItem::*;
                     match e {
-                        Expr(e) => Expr(e.clone().shift0(1, x)),
+                        Expr(e) => {
+                            let mut e = e.clone();
+                            e.shift0(1, x);
+                            Expr(e)
+                        }
                         Skip(n) if l == x => Skip(*n + 1),
                         Skip(n) => Skip(*n),
                     }
@@ -493,83 +507,64 @@ impl WHNF {
         WHNF::AppliedBuiltin(b, vec![])
     }
 
-    fn shift0(self, delta: isize, label: &Label) -> Self {
+    fn shift0(&mut self, delta: isize, label: &Label) {
         match self {
-            WHNF::Lam(x, t, (ctx, e)) => WHNF::Lam(
-                x,
-                t.shift0(delta, label),
-                (ctx, shift(delta, &V(label.clone(), 1), &e)),
-            ),
-            WHNF::AppliedBuiltin(b, args) => WHNF::AppliedBuiltin(
-                b,
-                args.into_iter().map(|e| e.shift0(delta, label)).collect(),
-            ),
-            WHNF::OptionalSomeClosure(n) => {
-                WHNF::OptionalSomeClosure(n.shift0(delta, label))
+            WHNF::NaturalSuccClosure
+            | WHNF::BoolLit(_)
+            | WHNF::NaturalLit(_)
+            | WHNF::IntegerLit(_) => {}
+            WHNF::EmptyOptionalLit(n)
+            | WHNF::NEOptionalLit(n)
+            | WHNF::OptionalSomeClosure(n)
+            | WHNF::EmptyListLit(n) => {
+                n.shift0(delta, label);
             }
-            WHNF::ListConsClosure(t, v) => WHNF::ListConsClosure(
-                t.shift0(delta, label),
-                v.map(|v| v.shift0(delta, label)),
-            ),
-            WHNF::NaturalSuccClosure => WHNF::NaturalSuccClosure,
-            WHNF::BoolLit(b) => WHNF::BoolLit(b),
-            WHNF::NaturalLit(n) => WHNF::NaturalLit(n),
-            WHNF::IntegerLit(n) => WHNF::IntegerLit(n),
-            WHNF::EmptyOptionalLit(n) => {
-                WHNF::EmptyOptionalLit(n.shift0(delta, label))
+            WHNF::Lam(_, t, (_, e)) => {
+                t.shift0(delta, label);
+                shift_mut(delta, &V(label.clone(), 1), e);
             }
-            WHNF::NEOptionalLit(n) => {
-                WHNF::NEOptionalLit(n.shift0(delta, label))
+            WHNF::AppliedBuiltin(_, args) => {
+                for x in args.iter_mut() {
+                    x.shift0(delta, label);
+                }
             }
-            WHNF::EmptyListLit(n) => WHNF::EmptyListLit(n.shift0(delta, label)),
-            WHNF::NEListLit(elts) => WHNF::NEListLit(
-                elts.into_iter().map(|n| n.shift0(delta, label)).collect(),
-            ),
-            WHNF::RecordLit(kvs) => WHNF::RecordLit(
-                kvs.into_iter()
-                    .map(|(k, v)| (k, v.shift0(delta, label)))
-                    .collect(),
-            ),
-            WHNF::RecordType(kts) => WHNF::RecordType(
-                kts.into_iter()
-                    .map(|(k, v)| (k, v.shift0(delta, label)))
-                    .collect(),
-            ),
-            WHNF::UnionType(ctx, kts) => WHNF::UnionType(
-                ctx,
-                kts.into_iter()
-                    .map(|(k, v)| (k, v.map(|v| shift0(delta, label, &v))))
-                    .collect(),
-            ),
-            WHNF::UnionConstructor(ctx, l, kts) => {
-                let kts = kts
-                    .into_iter()
-                    .map(|(k, v)| (k, v.map(|v| shift0(delta, label, &v))))
-                    .collect();
-                WHNF::UnionConstructor(ctx, l, kts)
+            WHNF::ListConsClosure(t, v) => {
+                t.shift0(delta, label);
+                for x in v.iter_mut() {
+                    x.shift0(delta, label);
+                }
             }
-            WHNF::UnionLit(l, v, (kts_ctx, kts)) => WHNF::UnionLit(
-                l,
-                v.shift0(delta, label),
-                (
-                    kts_ctx,
-                    kts.into_iter()
-                        .map(|(k, v)| (k, v.map(|v| shift0(delta, label, &v))))
-                        .collect(),
-                ),
-            ),
-            WHNF::TextLit(elts) => WHNF::TextLit(
-                elts.into_iter()
-                    .map(|contents| {
-                        use InterpolatedTextContents::{Expr, Text};
-                        match contents {
-                            Expr(n) => Expr(n.shift0(delta, label)),
-                            Text(s) => Text(s),
-                        }
-                    })
-                    .collect(),
-            ),
-            WHNF::Expr(e) => WHNF::Expr(shift0(delta, label, &e)),
+            WHNF::NEListLit(elts) => {
+                for x in elts.iter_mut() {
+                    x.shift0(delta, label);
+                }
+            }
+            WHNF::RecordLit(kvs) | WHNF::RecordType(kvs) => {
+                for x in kvs.values_mut() {
+                    x.shift0(delta, label);
+                }
+            }
+            WHNF::UnionType(_, kts) | WHNF::UnionConstructor(_, _, kts) => {
+                for x in kts.values_mut().flat_map(|opt| opt) {
+                    shift0_mut(delta, label, x);
+                }
+            }
+            WHNF::UnionLit(_, v, (_, kts)) => {
+                v.shift0(delta, label);
+                for x in kts.values_mut().flat_map(|opt| opt) {
+                    shift0_mut(delta, label, x);
+                }
+            }
+            WHNF::TextLit(elts) => {
+                for x in elts.iter_mut() {
+                    use InterpolatedTextContents::{Expr, Text};
+                    match x {
+                        Expr(n) => n.shift0(delta, label),
+                        Text(_) => {}
+                    }
+                }
+            }
+            WHNF::Expr(e) => shift0_mut(delta, label, e),
         }
     }
 }
@@ -599,14 +594,10 @@ impl Now {
         }
     }
 
-    fn shift0(self, delta: isize, label: &Label) -> Self {
+    fn shift0(&mut self, delta: isize, label: &Label) {
         match self {
-            Now::Normalized(v) => {
-                Now::Normalized(Box::new(v.shift0(delta, label)))
-            }
-            Now::Unnormalized(ctx, e) => {
-                Now::Unnormalized(ctx, shift0(delta, label, &e))
-            }
+            Now::Normalized(v) => v.shift0(delta, label),
+            Now::Unnormalized(_, e) => shift0_mut(delta, label, e),
         }
     }
 }
-- 
cgit v1.2.3


From 5812a53cc9241703bd35586da0036dc170ab3721 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 23:07:00 +0200
Subject: Implement more normalization simplifications

---
 dhall/src/normalize.rs | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index ec25010..9e7c531 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -667,11 +667,16 @@ fn normalize_whnf(ctx: NormalizationContext, expr: InputSubExpr) -> WHNF {
             match b {
                 WHNF::BoolLit(true) => normalize_whnf(ctx, e1.clone()),
                 WHNF::BoolLit(false) => normalize_whnf(ctx, e2.clone()),
-                _ => normalize_last_layer(ExprF::BoolIf(
-                    b,
-                    normalize_whnf(ctx.clone(), e1.clone()),
-                    normalize_whnf(ctx, e2.clone()),
-                )),
+                b => {
+                    let e1 = normalize_whnf(ctx.clone(), e1.clone());
+                    let e2 = normalize_whnf(ctx, e2.clone());
+                    match (e1, e2) {
+                        (WHNF::BoolLit(true), WHNF::BoolLit(false)) => b,
+                        (e1, e2) => {
+                            normalize_last_layer(ExprF::BoolIf(b, e1, e2))
+                        }
+                    }
+                }
             }
         }
         expr => {
@@ -736,6 +741,8 @@ fn normalize_last_layer(expr: ExprF<WHNF, Label, X, X>) -> WHNF {
             x.append(&mut y);
             TextLit(x)
         }
+        ExprF::BinOp(TextAppend, TextLit(x), y) if x.is_empty() => y,
+        ExprF::BinOp(TextAppend, x, TextLit(y)) if y.is_empty() => x,
 
         ExprF::Field(UnionType(ctx, kts), l) => UnionConstructor(ctx, l, kts),
         ExprF::Field(RecordLit(mut kvs), l) => match kvs.remove(&l) {
@@ -981,7 +988,7 @@ mod spec_tests {
     // norm!(success_unit_IfAlternativesIdentical, "unit/IfAlternativesIdentical");
     norm!(success_unit_IfFalse, "unit/IfFalse");
     norm!(success_unit_IfNormalizePredicateAndBranches, "unit/IfNormalizePredicateAndBranches");
-    // norm!(success_unit_IfTrivial, "unit/IfTrivial");
+    norm!(success_unit_IfTrivial, "unit/IfTrivial");
     norm!(success_unit_IfTrue, "unit/IfTrue");
     norm!(success_unit_Integer, "unit/Integer");
     norm!(success_unit_IntegerNegative, "unit/IntegerNegative");
@@ -1075,9 +1082,9 @@ mod spec_tests {
     norm!(success_unit_OperatorPlusNormalizeArguments, "unit/OperatorPlusNormalizeArguments");
     norm!(success_unit_OperatorPlusOneAndOne, "unit/OperatorPlusOneAndOne");
     norm!(success_unit_OperatorPlusRhsZero, "unit/OperatorPlusRhsZero");
-    // norm!(success_unit_OperatorTextConcatenateLhsEmpty, "unit/OperatorTextConcatenateLhsEmpty");
-    // norm!(success_unit_OperatorTextConcatenateNormalizeArguments, "unit/OperatorTextConcatenateNormalizeArguments");
-    // norm!(success_unit_OperatorTextConcatenateRhsEmpty, "unit/OperatorTextConcatenateRhsEmpty");
+    norm!(success_unit_OperatorTextConcatenateLhsEmpty, "unit/OperatorTextConcatenateLhsEmpty");
+    norm!(success_unit_OperatorTextConcatenateNormalizeArguments, "unit/OperatorTextConcatenateNormalizeArguments");
+    norm!(success_unit_OperatorTextConcatenateRhsEmpty, "unit/OperatorTextConcatenateRhsEmpty");
     norm!(success_unit_OperatorTextConcatenateTextText, "unit/OperatorTextConcatenateTextText");
     norm!(success_unit_OperatorTimesLhsOne, "unit/OperatorTimesLhsOne");
     norm!(success_unit_OperatorTimesLhsZero, "unit/OperatorTimesLhsZero");
-- 
cgit v1.2.3


From 83bc67d4572fe7961842f915d5559ee489e13dfd Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 20 Apr 2019 23:12:25 +0200
Subject: An empty optional value is purely semantic

---
 dhall/src/binary.rs    |  2 +-
 dhall/src/normalize.rs | 13 +++++--------
 dhall/src/typecheck.rs |  8 +-------
 3 files changed, 7 insertions(+), 16 deletions(-)

(limited to 'dhall/src')

diff --git a/dhall/src/binary.rs b/dhall/src/binary.rs
index 62ebcf7..7ded3a5 100644
--- a/dhall/src/binary.rs
+++ b/dhall/src/binary.rs
@@ -111,7 +111,7 @@ fn cbor_value_to_dhall(data: &cbor::Value) -> Result<ParsedExpr, DecodeError> {
             }
             [U64(5), Null, x] => {
                 let x = cbor_value_to_dhall(&x)?;
-                NEOptionalLit(x)
+                SomeLit(x)
             }
             [U64(5), t, x] => {
                 let x = cbor_value_to_dhall(&x)?;
diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 9e7c531..f092c4d 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -366,10 +366,12 @@ impl WHNF {
             WHNF::NaturalLit(n) => rc(ExprF::NaturalLit(n)),
             WHNF::IntegerLit(n) => rc(ExprF::IntegerLit(n)),
             WHNF::EmptyOptionalLit(n) => {
-                rc(ExprF::EmptyOptionalLit(n.normalize().normalize_to_expr()))
+                WHNF::Expr(rc(ExprF::Builtin(Builtin::OptionalNone)))
+                    .app(n.normalize())
+                    .normalize_to_expr()
             }
             WHNF::NEOptionalLit(n) => {
-                rc(ExprF::NEOptionalLit(n.normalize().normalize_to_expr()))
+                rc(ExprF::SomeLit(n.normalize().normalize_to_expr()))
             }
             WHNF::EmptyListLit(n) => {
                 rc(ExprF::EmptyListLit(n.normalize().normalize_to_expr()))
@@ -628,12 +630,7 @@ fn normalize_whnf(ctx: NormalizationContext, expr: InputSubExpr) -> WHNF {
         ExprF::OldOptionalLit(Some(e), _) => {
             WHNF::NEOptionalLit(Now::new(ctx, e.clone()))
         }
-        ExprF::EmptyOptionalLit(e) => {
-            WHNF::EmptyOptionalLit(Now::new(ctx, e.clone()))
-        }
-        ExprF::NEOptionalLit(e) => {
-            WHNF::NEOptionalLit(Now::new(ctx, e.clone()))
-        }
+        ExprF::SomeLit(e) => WHNF::NEOptionalLit(Now::new(ctx, e.clone())),
         ExprF::EmptyListLit(e) => WHNF::EmptyListLit(Now::new(ctx, e.clone())),
         ExprF::NEListLit(elts) => WHNF::NEListLit(
             elts.iter()
diff --git a/dhall/src/typecheck.rs b/dhall/src/typecheck.rs
index ddb96da..b26f845 100644
--- a/dhall/src/typecheck.rs
+++ b/dhall/src/typecheck.rs
@@ -563,13 +563,7 @@ fn type_last_layer(
             let e = dhall::subexpr!(Some x : Optional t);
             Ok(RetType(type_with(ctx, e)?.get_type()?.into_owned()))
         }
-        EmptyOptionalLit(t) => {
-            let t = t.normalize();
-            ensure_simple_type!(t, mkerr(InvalidOptionalType(t)));
-            let t = t.embed();
-            Ok(RetExpr(dhall::expr!(Optional t)))
-        }
-        NEOptionalLit(x) => {
+        SomeLit(x) => {
             let tx = x.get_type_move()?;
             ensure_simple_type!(
                 tx,
-- 
cgit v1.2.3