From bb1f698c23a83f60020a72bb5be1f9a386c60d44 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 18 Apr 2019 11:58:21 +0200
Subject: Start cleaning up the mess of mapping functions

---
 dhall/src/normalize.rs       |   1 -
 dhall_core/src/core.rs       | 111 +++++++++++++++++++++++++++++++++++--------
 dhall_core/src/visitor.rs    |  42 +++++++++++++++-
 dhall_generator/src/quote.rs |   4 +-
 4 files changed, 132 insertions(+), 26 deletions(-)

diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index e0ed96c..9110624 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -333,7 +333,6 @@ fn normalize_ref(expr: &Expr<X, Normalized<'static>>) -> Expr<X, X> {
         DoneAsIs => match expr.map_ref_simple(ExprF::roll) {
             e => e.map_ref(
                 SubExpr::clone,
-                |_, e| e.clone(),
                 X::clone,
                 |_| unreachable!(),
                 Label::clone,
diff --git a/dhall_core/src/core.rs b/dhall_core/src/core.rs
index bfe769f..24b4401 100644
--- a/dhall_core/src/core.rs
+++ b/dhall_core/src/core.rs
@@ -232,7 +232,6 @@ impl<S, A> Expr<S, A> {
     {
         self.map_ref(
             |x| rc(map_expr(x.as_ref())),
-            |_, x| rc(map_expr(x.as_ref())),
             map_note,
             map_embed,
             map_label,
@@ -290,7 +289,19 @@ impl<N: Clone, E> Expr<N, E> {
 }
 
 impl<SE, L, N, E> ExprF<SE, L, N, E> {
-    pub fn traverse_ref<'a, SE2, L2, N2, E2, Err, F1, F2, F3, F4, F5>(
+    pub fn traverse_ref_with_special_handling_of_binders<
+        'a,
+        SE2,
+        L2,
+        N2,
+        E2,
+        Err,
+        F1,
+        F2,
+        F3,
+        F4,
+        F5,
+    >(
         &'a self,
         visit_subexpr: F1,
         visit_under_binder: F2,
@@ -307,7 +318,7 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
         F4: FnOnce(&'a E) -> Result<E2, Err>,
         F5: FnMut(&'a L) -> Result<L2, Err>,
     {
-        self.visit(visitor::TraverseRefVisitor {
+        self.visit(visitor::TraverseRefWithBindersVisitor {
             visit_subexpr,
             visit_under_binder,
             visit_note,
@@ -316,12 +327,69 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
         })
     }
 
-    pub fn map_ref<'a, SE2, L2, N2, E2, F1, F2, F3, F4, F5>(
+    pub fn traverse_ref<'a, SE2, L2, N2, E2, Err, F1, F3, F4, F5>(
+        &'a self,
+        visit_subexpr: F1,
+        visit_note: F3,
+        visit_embed: F4,
+        visit_label: F5,
+    ) -> Result<ExprF<SE2, L2, N2, E2>, Err>
+    where
+        L: Ord,
+        L2: Ord,
+        F1: FnMut(&'a SE) -> Result<SE2, Err>,
+        F3: FnOnce(&'a N) -> Result<N2, Err>,
+        F4: FnOnce(&'a E) -> Result<E2, Err>,
+        F5: FnMut(&'a L) -> Result<L2, Err>,
+    {
+        self.visit(visitor::TraverseRefVisitor {
+            visit_subexpr,
+            visit_note,
+            visit_embed,
+            visit_label,
+        })
+    }
+
+    pub fn map_ref<'a, SE2, L2, N2, E2, F1, F3, F4, F5>(
+        &'a self,
+        mut map_subexpr: F1,
+        map_note: F3,
+        map_embed: F4,
+        mut map_label: F5,
+    ) -> ExprF<SE2, L2, N2, E2>
+    where
+        L: Ord,
+        L2: Ord,
+        F1: FnMut(&'a SE) -> SE2,
+        F3: FnOnce(&'a N) -> N2,
+        F4: FnOnce(&'a E) -> E2,
+        F5: FnMut(&'a L) -> L2,
+    {
+        trivial_result(self.traverse_ref(
+            |x| Ok(map_subexpr(x)),
+            |x| Ok(map_note(x)),
+            |x| Ok(map_embed(x)),
+            |x| Ok(map_label(x)),
+        ))
+    }
+
+    pub fn map_ref_with_special_handling_of_binders<
+        'a,
+        SE2,
+        L2,
+        N2,
+        E2,
+        F1,
+        F2,
+        F3,
+        F4,
+        F5,
+    >(
         &'a self,
         mut map_subexpr: F1,
         mut map_under_binder: F2,
-        mut map_note: F3,
-        mut map_embed: F4,
+        map_note: F3,
+        map_embed: F4,
         mut map_label: F5,
     ) -> ExprF<SE2, L2, N2, E2>
     where
@@ -329,11 +397,11 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
         L2: Ord,
         F1: FnMut(&'a SE) -> SE2,
         F2: FnMut(&'a L, &'a SE) -> SE2,
-        F3: FnMut(&'a N) -> N2,
-        F4: FnMut(&'a E) -> E2,
+        F3: FnOnce(&'a N) -> N2,
+        F4: FnOnce(&'a E) -> E2,
         F5: FnMut(&'a L) -> L2,
     {
-        trivial_result(self.traverse_ref(
+        trivial_result(self.traverse_ref_with_special_handling_of_binders(
             |x| Ok(map_subexpr(x)),
             |l, x| Ok(map_under_binder(l, x)),
             |x| Ok(map_note(x)),
@@ -375,7 +443,11 @@ impl<N, E> SubExpr<N, E> {
         self.0.as_ref()
     }
 
-    fn map_ref<'a, F1, F2>(&'a self, map_expr: F1, map_under_binder: F2) -> Self
+    pub fn map_subexprs_with_special_handling_of_binders<'a, F1, F2>(
+        &'a self,
+        map_expr: F1,
+        map_under_binder: F2,
+    ) -> Self
     where
         F1: FnMut(&'a Self) -> Self,
         F2: FnMut(&'a Label, &'a Self) -> Self,
@@ -383,9 +455,13 @@ impl<N, E> SubExpr<N, E> {
         match self.as_ref() {
             ExprF::Embed(_) => SubExpr::clone(self),
             // Recursive call
-            ExprF::Note(_, e) => e.map_ref(map_expr, map_under_binder),
+            ExprF::Note(_, e) => e
+                .map_subexprs_with_special_handling_of_binders(
+                    map_expr,
+                    map_under_binder,
+                ),
             // Call ExprF::map_ref
-            e => rc(e.map_ref(
+            e => rc(e.map_ref_with_special_handling_of_binders(
                 map_expr,
                 map_under_binder,
                 |_| unreachable!(),
@@ -395,13 +471,6 @@ impl<N, E> SubExpr<N, E> {
         }
     }
 
-    pub fn map_ref_simple<F1>(&self, map_expr: F1) -> Self
-    where
-        F1: Fn(&Self) -> Self,
-    {
-        self.map_ref(&map_expr, |_, e| map_expr(e))
-    }
-
     pub fn unroll(&self) -> Expr<N, E>
     where
         N: Clone,
@@ -513,7 +582,7 @@ pub fn shift<S, A>(
     use crate::ExprF::*;
     match in_expr.as_ref() {
         Var(v) => rc(Var(shift_var(delta, var, v))),
-        _ => in_expr.map_ref(
+        _ => in_expr.map_subexprs_with_special_handling_of_binders(
             |e| shift(delta, var, e),
             |l: &Label, e| {
                 let vl = V(l.clone(), 0);
@@ -541,7 +610,7 @@ pub fn subst_shift<S, A>(
     match in_expr.as_ref() {
         Var(v) if v == var => SubExpr::clone(value),
         Var(v) => rc(Var(shift_var(-1, var, v))),
-        _ => in_expr.map_ref(
+        _ => in_expr.map_subexprs_with_special_handling_of_binders(
             |e| subst_shift(var, &value, e),
             |l: &Label, e| {
                 let vl = V(l.clone(), 0);
diff --git a/dhall_core/src/visitor.rs b/dhall_core/src/visitor.rs
index c123275..c6b7321 100644
--- a/dhall_core/src/visitor.rs
+++ b/dhall_core/src/visitor.rs
@@ -302,7 +302,7 @@ where
     }
 }
 
-pub struct TraverseRefVisitor<F1, F2, F3, F4, F5> {
+pub struct TraverseRefWithBindersVisitor<F1, F2, F3, F4, F5> {
     pub visit_subexpr: F1,
     pub visit_under_binder: F2,
     pub visit_note: F3,
@@ -312,7 +312,7 @@ pub struct TraverseRefVisitor<F1, F2, F3, F4, F5> {
 
 impl<'a, SE, L, N, E, SE2, L2, N2, E2, Err, F1, F2, F3, F4, F5>
     ExprFFallibleVisitor<'a, SE, SE2, L, L2, N, N2, E, E2>
-    for TraverseRefVisitor<F1, F2, F3, F4, F5>
+    for TraverseRefWithBindersVisitor<F1, F2, F3, F4, F5>
 where
     SE: 'a,
     L: 'a,
@@ -349,6 +349,44 @@ where
     }
 }
 
+pub struct TraverseRefVisitor<F1, F2, F3, F4> {
+    pub visit_subexpr: F1,
+    pub visit_note: F2,
+    pub visit_embed: F3,
+    pub visit_label: F4,
+}
+
+impl<'a, SE, L, N, E, SE2, L2, N2, E2, Err, F1, F2, F3, F4>
+    ExprFFallibleVisitor<'a, SE, SE2, L, L2, N, N2, E, E2>
+    for TraverseRefVisitor<F1, F2, F3, F4>
+where
+    SE: 'a,
+    L: 'a,
+    N: 'a,
+    E: 'a,
+    L: Ord,
+    L2: Ord,
+    F1: FnMut(&'a SE) -> Result<SE2, Err>,
+    F2: FnOnce(&'a N) -> Result<N2, Err>,
+    F3: FnOnce(&'a E) -> Result<E2, Err>,
+    F4: FnMut(&'a L) -> Result<L2, Err>,
+{
+    type Error = Err;
+
+    fn visit_subexpr(&mut self, subexpr: &'a SE) -> Result<SE2, Self::Error> {
+        (self.visit_subexpr)(subexpr)
+    }
+    fn visit_note(self, note: &'a N) -> Result<N2, Self::Error> {
+        (self.visit_note)(note)
+    }
+    fn visit_embed(self, embed: &'a E) -> Result<E2, Self::Error> {
+        (self.visit_embed)(embed)
+    }
+    fn visit_label(&mut self, label: &'a L) -> Result<L2, Self::Error> {
+        (self.visit_label)(label)
+    }
+}
+
 pub struct TraverseRefSimpleVisitor<F1> {
     pub visit_subexpr: F1,
 }
diff --git a/dhall_generator/src/quote.rs b/dhall_generator/src/quote.rs
index c335666..7128511 100644
--- a/dhall_generator/src/quote.rs
+++ b/dhall_generator/src/quote.rs
@@ -103,7 +103,7 @@ fn quote_subexpr(
     ctx: &Context<Label, ()>,
 ) -> TokenStream {
     use dhall_core::ExprF::*;
-    match expr.as_ref().map_ref(
+    match expr.as_ref().map_ref_with_special_handling_of_binders(
         |e| quote_subexpr(e, ctx),
         |l, e| quote_subexpr(e, &ctx.insert(l.clone(), ())),
         |_| unreachable!(),
@@ -138,7 +138,7 @@ fn quote_subexpr(
 // to be of type SubExpr<_, _>.
 fn quote_expr(expr: &Expr<X, X>, ctx: &Context<Label, ()>) -> TokenStream {
     use dhall_core::ExprF::*;
-    match expr.map_ref(
+    match expr.map_ref_with_special_handling_of_binders(
         |e| quote_subexpr(e, ctx),
         |l, e| quote_subexpr(e, &ctx.insert(l.clone(), ())),
         |_| unreachable!(),
-- 
cgit v1.2.3


From 546fc00e893ba214b7731c95cfaf493644b50447 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 18 Apr 2019 12:01:21 +0200
Subject: Consistent type variable naming

---
 dhall_core/src/core.rs | 67 +++++++++++++++++++++++++-------------------------
 1 file changed, 34 insertions(+), 33 deletions(-)

diff --git a/dhall_core/src/core.rs b/dhall_core/src/core.rs
index 24b4401..a233d67 100644
--- a/dhall_core/src/core.rs
+++ b/dhall_core/src/core.rs
@@ -213,21 +213,21 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
     }
 }
 
-impl<S, A> Expr<S, A> {
-    pub fn map_shallow<T, B, F1, F2, F3, F4>(
+impl<N, E> Expr<N, E> {
+    pub fn map_shallow<N2, E2, F1, F2, F3, F4>(
         &self,
         map_expr: F1,
         map_note: F2,
         map_embed: F3,
         map_label: F4,
-    ) -> Expr<T, B>
+    ) -> Expr<N2, E2>
     where
-        A: Clone,
-        T: Clone,
-        S: Clone,
-        F1: Fn(&Self) -> Expr<T, B>,
-        F2: Fn(&S) -> T,
-        F3: Fn(&A) -> B,
+        E: Clone,
+        N2: Clone,
+        N: Clone,
+        F1: Fn(&Self) -> Expr<N2, E2>,
+        F2: Fn(&N) -> N2,
+        F3: Fn(&E) -> E2,
         F4: Fn(&Label) -> Label,
     {
         self.map_ref(
@@ -238,42 +238,43 @@ impl<S, A> Expr<S, A> {
         )
     }
 
-    pub fn map_embed<B, F>(&self, map_embed: &F) -> Expr<S, B>
+    pub fn map_embed<E2, F>(&self, map_embed: &F) -> Expr<N, E2>
     where
-        A: Clone,
-        S: Clone,
-        F: Fn(&A) -> B,
+        E: Clone,
+        N: Clone,
+        F: Fn(&E) -> E2,
     {
-        let recurse = |e: &Expr<S, A>| -> Expr<S, B> { e.map_embed(map_embed) };
-        self.map_shallow(recurse, S::clone, map_embed, Label::clone)
+        let recurse =
+            |e: &Expr<N, E>| -> Expr<N, E2> { e.map_embed(map_embed) };
+        self.map_shallow(recurse, N::clone, map_embed, Label::clone)
     }
 
-    pub fn traverse_embed<B, Err, F>(
+    pub fn traverse_embed<E2, Err, F>(
         &self,
         map_embed: F,
-    ) -> Result<Expr<S, B>, Err>
+    ) -> Result<Expr<N, E2>, Err>
     where
-        S: Clone,
-        B: Clone,
-        F: FnMut(&A) -> Result<B, Err>,
+        N: Clone,
+        E2: Clone,
+        F: FnMut(&E) -> Result<E2, Err>,
     {
         self.visit(&mut visitor::TraverseEmbedVisitor(map_embed))
     }
 
     pub fn map_label<F>(&self, map_label: &F) -> Self
     where
-        A: Clone,
-        S: Clone,
+        E: Clone,
+        N: Clone,
         F: Fn(&Label) -> Label,
     {
         let recurse = |e: &Self| -> Self { e.map_label(map_label) };
-        self.map_shallow(recurse, S::clone, A::clone, map_label)
+        self.map_shallow(recurse, N::clone, E::clone, map_label)
     }
 
-    pub fn roll(&self) -> SubExpr<S, A>
+    pub fn roll(&self) -> SubExpr<N, E>
     where
-        S: Clone,
-        A: Clone,
+        N: Clone,
+        E: Clone,
     {
         rc(ExprF::clone(self))
     }
@@ -574,11 +575,11 @@ fn shift_var(delta: isize, var: &V<Label>, in_expr: &V<Label>) -> V<Label> {
 /// capture by shifting variable indices
 /// See https://github.com/dhall-lang/dhall-lang/blob/master/standard/semantics.md#shift
 /// for details
-pub fn shift<S, A>(
+pub fn shift<N, E>(
     delta: isize,
     var: &V<Label>,
-    in_expr: &SubExpr<S, A>,
-) -> SubExpr<S, A> {
+    in_expr: &SubExpr<N, E>,
+) -> SubExpr<N, E> {
     use crate::ExprF::*;
     match in_expr.as_ref() {
         Var(v) => rc(Var(shift_var(delta, var, v))),
@@ -601,11 +602,11 @@ pub fn shift<S, A>(
 /// subst_shift(x, v, e) = ↑(-1, x, e[x := ↑(1, x, v)])
 /// ```
 ///
-pub fn subst_shift<S, A>(
+pub fn subst_shift<N, E>(
     var: &V<Label>,
-    value: &SubExpr<S, A>,
-    in_expr: &SubExpr<S, A>,
-) -> SubExpr<S, A> {
+    value: &SubExpr<N, E>,
+    in_expr: &SubExpr<N, E>,
+) -> SubExpr<N, E> {
     use crate::ExprF::*;
     match in_expr.as_ref() {
         Var(v) if v == var => SubExpr::clone(value),
-- 
cgit v1.2.3


From 30397d3638b47557333935b24cfbfced69e40e9d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 18 Apr 2019 12:06:36 +0200
Subject: Merge impl blocks

---
 dhall_core/src/core.rs | 210 ++++++++++++++++++++++++-------------------------
 1 file changed, 104 insertions(+), 106 deletions(-)

diff --git a/dhall_core/src/core.rs b/dhall_core/src/core.rs
index a233d67..1c1aa23 100644
--- a/dhall_core/src/core.rs
+++ b/dhall_core/src/core.rs
@@ -211,85 +211,7 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
     {
         v.visit(self)
     }
-}
-
-impl<N, E> Expr<N, E> {
-    pub fn map_shallow<N2, E2, F1, F2, F3, F4>(
-        &self,
-        map_expr: F1,
-        map_note: F2,
-        map_embed: F3,
-        map_label: F4,
-    ) -> Expr<N2, E2>
-    where
-        E: Clone,
-        N2: Clone,
-        N: Clone,
-        F1: Fn(&Self) -> Expr<N2, E2>,
-        F2: Fn(&N) -> N2,
-        F3: Fn(&E) -> E2,
-        F4: Fn(&Label) -> Label,
-    {
-        self.map_ref(
-            |x| rc(map_expr(x.as_ref())),
-            map_note,
-            map_embed,
-            map_label,
-        )
-    }
 
-    pub fn map_embed<E2, F>(&self, map_embed: &F) -> Expr<N, E2>
-    where
-        E: Clone,
-        N: Clone,
-        F: Fn(&E) -> E2,
-    {
-        let recurse =
-            |e: &Expr<N, E>| -> Expr<N, E2> { e.map_embed(map_embed) };
-        self.map_shallow(recurse, N::clone, map_embed, Label::clone)
-    }
-
-    pub fn traverse_embed<E2, Err, F>(
-        &self,
-        map_embed: F,
-    ) -> Result<Expr<N, E2>, Err>
-    where
-        N: Clone,
-        E2: Clone,
-        F: FnMut(&E) -> Result<E2, Err>,
-    {
-        self.visit(&mut visitor::TraverseEmbedVisitor(map_embed))
-    }
-
-    pub fn map_label<F>(&self, map_label: &F) -> Self
-    where
-        E: Clone,
-        N: Clone,
-        F: Fn(&Label) -> Label,
-    {
-        let recurse = |e: &Self| -> Self { e.map_label(map_label) };
-        self.map_shallow(recurse, N::clone, E::clone, map_label)
-    }
-
-    pub fn roll(&self) -> SubExpr<N, E>
-    where
-        N: Clone,
-        E: Clone,
-    {
-        rc(ExprF::clone(self))
-    }
-}
-
-impl<N: Clone, E> Expr<N, E> {
-    pub fn squash_embed<E2: Clone>(
-        &self,
-        f: impl FnMut(&E) -> SubExpr<N, E2>,
-    ) -> SubExpr<N, E2> {
-        rc(self.visit(&mut visitor::SquashEmbedVisitor(f)))
-    }
-}
-
-impl<SE, L, N, E> ExprF<SE, L, N, E> {
     pub fn traverse_ref_with_special_handling_of_binders<
         'a,
         SE2,
@@ -439,6 +361,100 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
     }
 }
 
+impl<N, E> Expr<N, E> {
+    pub fn map_shallow<N2, E2, F1, F2, F3, F4>(
+        &self,
+        map_expr: F1,
+        map_note: F2,
+        map_embed: F3,
+        map_label: F4,
+    ) -> Expr<N2, E2>
+    where
+        E: Clone,
+        N2: Clone,
+        N: Clone,
+        F1: Fn(&Self) -> Expr<N2, E2>,
+        F2: Fn(&N) -> N2,
+        F3: Fn(&E) -> E2,
+        F4: Fn(&Label) -> Label,
+    {
+        self.map_ref(
+            |x| rc(map_expr(x.as_ref())),
+            map_note,
+            map_embed,
+            map_label,
+        )
+    }
+
+    pub fn map_embed<E2, F>(&self, map_embed: &F) -> Expr<N, E2>
+    where
+        E: Clone,
+        N: Clone,
+        F: Fn(&E) -> E2,
+    {
+        let recurse =
+            |e: &Expr<N, E>| -> Expr<N, E2> { e.map_embed(map_embed) };
+        self.map_shallow(recurse, N::clone, map_embed, Label::clone)
+    }
+
+    pub fn traverse_embed<E2, Err, F>(
+        &self,
+        map_embed: F,
+    ) -> Result<Expr<N, E2>, Err>
+    where
+        N: Clone,
+        E2: Clone,
+        F: FnMut(&E) -> Result<E2, Err>,
+    {
+        self.visit(&mut visitor::TraverseEmbedVisitor(map_embed))
+    }
+
+    pub fn map_label<F>(&self, map_label: &F) -> Self
+    where
+        E: Clone,
+        N: Clone,
+        F: Fn(&Label) -> Label,
+    {
+        let recurse = |e: &Self| -> Self { e.map_label(map_label) };
+        self.map_shallow(recurse, N::clone, E::clone, map_label)
+    }
+
+    pub fn roll(&self) -> SubExpr<N, E>
+    where
+        N: Clone,
+        E: Clone,
+    {
+        rc(ExprF::clone(self))
+    }
+
+    pub fn squash_embed<E2>(
+        &self,
+        f: impl FnMut(&E) -> SubExpr<N, E2>,
+    ) -> SubExpr<N, E2>
+    where
+        N: Clone,
+        E2: Clone,
+    {
+        rc(self.visit(&mut visitor::SquashEmbedVisitor(f)))
+    }
+}
+
+impl<E: Clone> Expr<X, E> {
+    pub fn note_absurd<N>(&self) -> Expr<N, E> {
+        self.visit(&mut visitor::NoteAbsurdVisitor)
+    }
+}
+
+impl<N: Clone> Expr<N, X> {
+    // Deprecated, use embed_absurd instead
+    pub fn absurd_rec<T>(&self) -> Expr<N, T> {
+        self.embed_absurd()
+    }
+    pub fn embed_absurd<T>(&self) -> Expr<N, T> {
+        self.visit(&mut visitor::EmbedAbsurdVisitor)
+    }
+}
+
 impl<N, E> SubExpr<N, E> {
     pub fn as_ref(&self) -> &Expr<N, E> {
         self.0.as_ref()
@@ -479,12 +495,22 @@ impl<N, E> SubExpr<N, E> {
     {
         ExprF::clone(self.as_ref())
     }
+
+    pub fn unnote(&self) -> SubExpr<X, E>
+    where
+        E: Clone,
+    {
+        rc(self.as_ref().visit(&mut visitor::UnNoteVisitor))
+    }
 }
 
 impl<N: Clone> SubExpr<N, X> {
     pub fn absurd<T>(&self) -> SubExpr<N, T> {
         rc(self.as_ref().absurd_rec())
     }
+    pub fn embed_absurd<T>(&self) -> SubExpr<N, T> {
+        rc(self.as_ref().embed_absurd())
+    }
 }
 
 impl<E: Clone> SubExpr<X, E> {
@@ -493,34 +519,6 @@ impl<E: Clone> SubExpr<X, E> {
     }
 }
 
-impl<E: Clone> Expr<X, E> {
-    pub fn note_absurd<N>(&self) -> Expr<N, E> {
-        self.visit(&mut visitor::NoteAbsurdVisitor)
-    }
-}
-
-impl<N, E: Clone> SubExpr<N, E> {
-    pub fn unnote(&self) -> SubExpr<X, E> {
-        rc(self.as_ref().visit(&mut visitor::UnNoteVisitor))
-    }
-}
-
-impl<N: Clone> Expr<N, X> {
-    // Deprecated, use embed_absurd instead
-    pub fn absurd_rec<T>(&self) -> Expr<N, T> {
-        self.embed_absurd()
-    }
-    pub fn embed_absurd<T>(&self) -> Expr<N, T> {
-        self.visit(&mut visitor::EmbedAbsurdVisitor)
-    }
-}
-
-impl<N: Clone> SubExpr<N, X> {
-    pub fn embed_absurd<T>(&self) -> SubExpr<N, T> {
-        rc(self.as_ref().embed_absurd())
-    }
-}
-
 impl<N, E> Clone for SubExpr<N, E> {
     fn clone(&self) -> Self {
         SubExpr(Rc::clone(&self.0))
-- 
cgit v1.2.3


From cb24b56d83479c0fd95bf4dd09879118f4e3afd6 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 18 Apr 2019 12:10:47 +0200
Subject: Deprecate some things

---
 dhall_core/src/core.rs   | 25 +++++--------------------
 dhall_core/src/parser.rs |  2 +-
 2 files changed, 6 insertions(+), 21 deletions(-)

diff --git a/dhall_core/src/core.rs b/dhall_core/src/core.rs
index 1c1aa23..d0e908b 100644
--- a/dhall_core/src/core.rs
+++ b/dhall_core/src/core.rs
@@ -472,6 +472,7 @@ impl<N, E> SubExpr<N, E> {
         match self.as_ref() {
             ExprF::Embed(_) => SubExpr::clone(self),
             // Recursive call
+            // TODO: don't discard the note !
             ExprF::Note(_, e) => e
                 .map_subexprs_with_special_handling_of_binders(
                     map_expr,
@@ -505,8 +506,9 @@ impl<N, E> SubExpr<N, E> {
 }
 
 impl<N: Clone> SubExpr<N, X> {
+    // Deprecated, use embed_absurd instead
     pub fn absurd<T>(&self) -> SubExpr<N, T> {
-        rc(self.as_ref().absurd_rec())
+        self.embed_absurd()
     }
     pub fn embed_absurd<T>(&self) -> SubExpr<N, T> {
         rc(self.as_ref().embed_absurd())
@@ -530,25 +532,8 @@ pub fn rc<N, E>(x: Expr<N, E>) -> SubExpr<N, E> {
     SubExpr(Rc::new(x))
 }
 
-pub fn app<N, E>(f: Expr<N, E>, args: Vec<SubExpr<N, E>>) -> Expr<N, E> {
-    if args.is_empty() {
-        f
-    } else {
-        ExprF::App(rc(f), args)
-    }
-}
-
-pub fn app_rc<N, E>(
-    f: SubExpr<N, E>,
-    args: Vec<SubExpr<N, E>>,
-) -> SubExpr<N, E> {
-    if args.is_empty() {
-        f
-    } else {
-        rc(ExprF::App(f, args))
-    }
-}
-
+/// Add an isize to an usize
+/// Panics on over/underflow
 fn add_ui(u: usize, i: isize) -> usize {
     if i < 0 {
         u.checked_sub(i.checked_neg().unwrap() as usize).unwrap()
diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs
index 1e47c16..2a30b2b 100644
--- a/dhall_core/src/parser.rs
+++ b/dhall_core/src/parser.rs
@@ -746,7 +746,7 @@ make_parser! {
     rule!(application_expression<ParsedExpr<'a>> as expression; span; children!(
         [expression(e)] => e,
         [expression(first), expression(rest)..] => {
-            spanned(span, app(first, rest.map(rc).collect()))
+            spanned(span, App(rc(first), rest.map(rc).collect()))
         },
     ));
 
-- 
cgit v1.2.3


From e68e34f361a29e0661201ac3c93a711a9884833f Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 18 Apr 2019 13:15:42 +0200
Subject: Reduce duplication between mapping functions

---
 dhall_core/src/core.rs       | 90 ++++++++++++++++----------------------------
 dhall_core/src/visitor.rs    |  1 -
 dhall_generator/src/quote.rs |  4 +-
 3 files changed, 35 insertions(+), 60 deletions(-)

diff --git a/dhall_core/src/core.rs b/dhall_core/src/core.rs
index d0e908b..7f9fd14 100644
--- a/dhall_core/src/core.rs
+++ b/dhall_core/src/core.rs
@@ -273,9 +273,21 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
         })
     }
 
-    pub fn map_ref<'a, SE2, L2, N2, E2, F1, F3, F4, F5>(
+    pub fn map_ref_with_special_handling_of_binders<
+        'a,
+        SE2,
+        L2,
+        N2,
+        E2,
+        F1,
+        F2,
+        F3,
+        F4,
+        F5,
+    >(
         &'a self,
         mut map_subexpr: F1,
+        mut map_under_binder: F2,
         map_note: F3,
         map_embed: F4,
         mut map_label: F5,
@@ -284,33 +296,23 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
         L: Ord,
         L2: Ord,
         F1: FnMut(&'a SE) -> SE2,
+        F2: FnMut(&'a L, &'a SE) -> SE2,
         F3: FnOnce(&'a N) -> N2,
         F4: FnOnce(&'a E) -> E2,
         F5: FnMut(&'a L) -> L2,
     {
-        trivial_result(self.traverse_ref(
+        trivial_result(self.traverse_ref_with_special_handling_of_binders(
             |x| Ok(map_subexpr(x)),
+            |l, x| Ok(map_under_binder(l, x)),
             |x| Ok(map_note(x)),
             |x| Ok(map_embed(x)),
             |x| Ok(map_label(x)),
         ))
     }
 
-    pub fn map_ref_with_special_handling_of_binders<
-        'a,
-        SE2,
-        L2,
-        N2,
-        E2,
-        F1,
-        F2,
-        F3,
-        F4,
-        F5,
-    >(
+    pub fn map_ref<'a, SE2, L2, N2, E2, F1, F3, F4, F5>(
         &'a self,
         mut map_subexpr: F1,
-        mut map_under_binder: F2,
         map_note: F3,
         map_embed: F4,
         mut map_label: F5,
@@ -319,14 +321,12 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
         L: Ord,
         L2: Ord,
         F1: FnMut(&'a SE) -> SE2,
-        F2: FnMut(&'a L, &'a SE) -> SE2,
         F3: FnOnce(&'a N) -> N2,
         F4: FnOnce(&'a E) -> E2,
         F5: FnMut(&'a L) -> L2,
     {
-        trivial_result(self.traverse_ref_with_special_handling_of_binders(
+        trivial_result(self.traverse_ref(
             |x| Ok(map_subexpr(x)),
-            |l, x| Ok(map_under_binder(l, x)),
             |x| Ok(map_note(x)),
             |x| Ok(map_embed(x)),
             |x| Ok(map_label(x)),
@@ -362,51 +362,24 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
 }
 
 impl<N, E> Expr<N, E> {
-    pub fn map_shallow<N2, E2, F1, F2, F3, F4>(
+    pub fn traverse_embed<E2, Err, F>(
         &self,
-        map_expr: F1,
-        map_note: F2,
-        map_embed: F3,
-        map_label: F4,
-    ) -> Expr<N2, E2>
+        map_embed: F,
+    ) -> Result<Expr<N, E2>, Err>
     where
-        E: Clone,
-        N2: Clone,
         N: Clone,
-        F1: Fn(&Self) -> Expr<N2, E2>,
-        F2: Fn(&N) -> N2,
-        F3: Fn(&E) -> E2,
-        F4: Fn(&Label) -> Label,
+        F: FnMut(&E) -> Result<E2, Err>,
     {
-        self.map_ref(
-            |x| rc(map_expr(x.as_ref())),
-            map_note,
-            map_embed,
-            map_label,
-        )
+        self.visit(&mut visitor::TraverseEmbedVisitor(map_embed))
     }
 
-    pub fn map_embed<E2, F>(&self, map_embed: &F) -> Expr<N, E2>
+    pub fn map_embed<E2, F>(&self, mut map_embed: F) -> Expr<N, E2>
     where
         E: Clone,
         N: Clone,
-        F: Fn(&E) -> E2,
+        F: FnMut(&E) -> E2,
     {
-        let recurse =
-            |e: &Expr<N, E>| -> Expr<N, E2> { e.map_embed(map_embed) };
-        self.map_shallow(recurse, N::clone, map_embed, Label::clone)
-    }
-
-    pub fn traverse_embed<E2, Err, F>(
-        &self,
-        map_embed: F,
-    ) -> Result<Expr<N, E2>, Err>
-    where
-        N: Clone,
-        E2: Clone,
-        F: FnMut(&E) -> Result<E2, Err>,
-    {
-        self.visit(&mut visitor::TraverseEmbedVisitor(map_embed))
+        trivial_result(self.traverse_embed(|x| Ok(map_embed(x))))
     }
 
     pub fn map_label<F>(&self, map_label: &F) -> Self
@@ -415,8 +388,10 @@ impl<N, E> Expr<N, E> {
         N: Clone,
         F: Fn(&Label) -> Label,
     {
-        let recurse = |e: &Self| -> Self { e.map_label(map_label) };
-        self.map_shallow(recurse, N::clone, E::clone, map_label)
+        let recurse = |e: &SubExpr<N, E>| -> SubExpr<N, E> {
+            rc(e.as_ref().map_label(map_label))
+        };
+        self.map_ref(recurse, N::clone, E::clone, map_label)
     }
 
     pub fn roll(&self) -> SubExpr<N, E>
@@ -447,11 +422,12 @@ impl<E: Clone> Expr<X, E> {
 
 impl<N: Clone> Expr<N, X> {
     // Deprecated, use embed_absurd instead
-    pub fn absurd_rec<T>(&self) -> Expr<N, T> {
+    pub fn absurd_rec<E>(&self) -> Expr<N, E> {
         self.embed_absurd()
     }
-    pub fn embed_absurd<T>(&self) -> Expr<N, T> {
+    pub fn embed_absurd<E>(&self) -> Expr<N, E> {
         self.visit(&mut visitor::EmbedAbsurdVisitor)
+        // self.visit(&mut visitor::SquashEmbedVisitor(|e| match *e {}))
     }
 }
 
diff --git a/dhall_core/src/visitor.rs b/dhall_core/src/visitor.rs
index c6b7321..053932d 100644
--- a/dhall_core/src/visitor.rs
+++ b/dhall_core/src/visitor.rs
@@ -433,7 +433,6 @@ impl<'a, 'b, N, E, E2, Err, F1>
     > for &'b mut TraverseEmbedVisitor<F1>
 where
     N: Clone + 'a,
-    E2: Clone,
     F1: FnMut(&E) -> Result<E2, Err>,
 {
     type Error = Err;
diff --git a/dhall_generator/src/quote.rs b/dhall_generator/src/quote.rs
index 7128511..d680288 100644
--- a/dhall_generator/src/quote.rs
+++ b/dhall_generator/src/quote.rs
@@ -10,7 +10,7 @@ pub fn expr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let expr: SubExpr<_, Import> = parse_expr(&input_str).unwrap().unnote();
     let no_import =
         |_: &Import| -> X { panic!("Don't use import in dhall::expr!()") };
-    let expr = expr.as_ref().map_embed(&no_import);
+    let expr = expr.as_ref().map_embed(no_import);
     let output = quote_expr(&expr, &Context::new());
     output.into()
 }
@@ -20,7 +20,7 @@ pub fn subexpr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let expr: SubExpr<_, Import> = parse_expr(&input_str).unwrap().unnote();
     let no_import =
         |_: &Import| -> X { panic!("Don't use import in dhall::subexpr!()") };
-    let expr = expr.as_ref().map_embed(&no_import);
+    let expr = expr.as_ref().map_embed(no_import);
     let output = quote_subexpr(&dhall_core::rc(expr), &Context::new());
     output.into()
 }
-- 
cgit v1.2.3


From bce1538a6b80702ef71749215dce339c9f22f09c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 18 Apr 2019 13:42:40 +0200
Subject: Add even more general visitor trait

---
 dhall_core/src/visitor.rs | 195 +++++++++++++++++++++++++++++++++-------------
 1 file changed, 140 insertions(+), 55 deletions(-)

diff --git a/dhall_core/src/visitor.rs b/dhall_core/src/visitor.rs
index 053932d..dcd860e 100644
--- a/dhall_core/src/visitor.rs
+++ b/dhall_core/src/visitor.rs
@@ -17,67 +17,49 @@ pub trait GenericVisitor<Input, Return>: Sized {
 /// time: the visitor itself. The visitor can then carry around multiple closures
 /// or just one, and Rust is ok with either. See for example TraverseRefVisitor
 /// and TraverseEmbedVisitor.
-pub trait ExprFFallibleVisitor<'a, SE1, SE2, L1, L2, N1, N2, E1, E2>:
-    Sized
-{
+/// This is very generic. For a more legible trait, see ExprFInFallibleVisitor
+pub trait ExprFVeryGenericVisitor<'a, Ret, SE1, L1, N1, E1>: Sized {
     type Error;
+    type SE2;
+    type L2;
+    type N2;
+    type E2;
 
-    fn visit_subexpr(&mut self, subexpr: &'a SE1) -> Result<SE2, Self::Error>;
-    fn visit_label(&mut self, label: &'a L1) -> Result<L2, Self::Error>;
-    fn visit_note(self, note: &'a N1) -> Result<N2, Self::Error>;
-    fn visit_embed(self, embed: &'a E1) -> Result<E2, Self::Error>;
-
-    fn visit_subexpr_under_binder(
-        mut self,
-        _label: &'a L1,
+    fn visit_subexpr(
+        &mut self,
         subexpr: &'a SE1,
-    ) -> Result<SE2, Self::Error> {
-        self.visit_subexpr(subexpr)
-    }
+    ) -> Result<Self::SE2, Self::Error>;
+    fn visit_label(&mut self, label: &'a L1) -> Result<Self::L2, Self::Error>;
 
     fn visit_binder(
-        mut self,
+        self,
         label: &'a L1,
         subexpr: &'a SE1,
-    ) -> Result<(L2, SE2), Self::Error> {
-        Ok((
-            self.visit_label(label)?,
-            self.visit_subexpr_under_binder(label, subexpr)?,
-        ))
-    }
+    ) -> Result<(Self::L2, Self::SE2), Self::Error>;
 
-    fn visit_embed_squash(
-        self,
-        embed: &'a E1,
-    ) -> Result<ExprF<SE2, L2, N2, E2>, Self::Error> {
-        Ok(ExprF::Embed(self.visit_embed(embed)?))
-    }
+    fn visit_embed_squash(self, embed: &'a E1) -> Result<Ret, Self::Error>;
 
     fn visit_note_squash(
-        mut self,
+        self,
         note: &'a N1,
         subexpr: &'a SE1,
-    ) -> Result<ExprF<SE2, L2, N2, E2>, Self::Error> {
-        let subexpr = self.visit_subexpr(subexpr)?;
-        let note = self.visit_note(note)?;
-        Ok(ExprF::Note(note, subexpr))
-    }
+    ) -> Result<Ret, Self::Error>;
+
+    // Called with the result of the map, in the non-embed/note case.
+    // Useful to change the result type, and/or avoid some loss of info
+    fn visit_resulting_exprf(
+        result: ExprF<Self::SE2, Self::L2, Self::N2, Self::E2>,
+    ) -> Result<Ret, Self::Error>;
 }
 
-impl<'a, T, SE1, SE2, L1, L2, N1, N2, E1, E2>
-    GenericVisitor<
-        &'a ExprF<SE1, L1, N1, E1>,
-        Result<ExprF<SE2, L2, N2, E2>, T::Error>,
-    > for T
+impl<'a, T, Ret, SE1, L1, N1, E1>
+    GenericVisitor<&'a ExprF<SE1, L1, N1, E1>, Result<Ret, T::Error>> for T
 where
     L1: Ord,
-    L2: Ord,
-    T: ExprFFallibleVisitor<'a, SE1, SE2, L1, L2, N1, N2, E1, E2>,
+    T::L2: Ord,
+    T: ExprFVeryGenericVisitor<'a, Ret, SE1, L1, N1, E1>,
 {
-    fn visit(
-        self,
-        input: &'a ExprF<SE1, L1, N1, E1>,
-    ) -> Result<ExprF<SE2, L2, N2, E2>, T::Error> {
+    fn visit(self, input: &'a ExprF<SE1, L1, N1, E1>) -> Result<Ret, T::Error> {
         fn vec<'a, T, U, Err, F: FnMut(&'a T) -> Result<U, Err>>(
             x: &'a [T],
             f: F,
@@ -93,27 +75,27 @@ where
                 None => None,
             })
         }
-        fn btmap<'a, V, SE, L, N, E, SE2, L2, N2, E2>(
+        fn btmap<'a, V, Ret, SE, L, N, E>(
             x: &'a BTreeMap<L, SE>,
             mut v: V,
-        ) -> Result<BTreeMap<L2, SE2>, V::Error>
+        ) -> Result<BTreeMap<V::L2, V::SE2>, V::Error>
         where
             L: Ord,
-            L2: Ord,
-            V: ExprFFallibleVisitor<'a, SE, SE2, L, L2, N, N2, E, E2>,
+            V::L2: Ord,
+            V: ExprFVeryGenericVisitor<'a, Ret, SE, L, N, E>,
         {
             x.iter()
                 .map(|(k, x)| Ok((v.visit_label(k)?, v.visit_subexpr(x)?)))
                 .collect()
         }
-        fn btoptmap<'a, V, SE, L, N, E, SE2, L2, N2, E2>(
+        fn btoptmap<'a, V, Ret, SE, L, N, E>(
             x: &'a BTreeMap<L, Option<SE>>,
             mut v: V,
-        ) -> Result<BTreeMap<L2, Option<SE2>>, V::Error>
+        ) -> Result<BTreeMap<V::L2, Option<V::SE2>>, V::Error>
         where
             L: Ord,
-            L2: Ord,
-            V: ExprFFallibleVisitor<'a, SE, SE2, L, L2, N, N2, E, E2>,
+            V::L2: Ord,
+            V: ExprFVeryGenericVisitor<'a, Ret, SE, L, N, E>,
         {
             x.iter()
                 .map(|(k, x)| {
@@ -130,7 +112,7 @@ where
 
         let mut v = self;
         use crate::ExprF::*;
-        Ok(match input {
+        T::visit_resulting_exprf(match input {
             Var(V(l, n)) => Var(V(v.visit_label(l)?, *n)),
             Lam(l, t, e) => {
                 let t = v.visit_subexpr(t)?;
@@ -195,12 +177,115 @@ where
             Projection(e, ls) => {
                 Projection(v.visit_subexpr(e)?, vec(ls, |l| v.visit_label(l))?)
             }
-            Note(n, e) => v.visit_note_squash(n, e)?,
-            Embed(a) => v.visit_embed_squash(a)?,
+            Note(n, e) => return v.visit_note_squash(n, e),
+            Embed(a) => return v.visit_embed_squash(a),
         })
     }
 }
 
+/// Like ExprFVeryGenericVisitor, but sets the return
+/// type to ExprF<_>
+pub trait ExprFFallibleVisitor<'a, SE1, SE2, L1, L2, N1, N2, E1, E2>:
+    Sized
+{
+    type Error;
+
+    fn visit_subexpr(&mut self, subexpr: &'a SE1) -> Result<SE2, Self::Error>;
+    fn visit_label(&mut self, label: &'a L1) -> Result<L2, Self::Error>;
+    fn visit_note(self, note: &'a N1) -> Result<N2, Self::Error>;
+    fn visit_embed(self, embed: &'a E1) -> Result<E2, Self::Error>;
+
+    fn visit_subexpr_under_binder(
+        mut self,
+        _label: &'a L1,
+        subexpr: &'a SE1,
+    ) -> Result<SE2, Self::Error> {
+        self.visit_subexpr(subexpr)
+    }
+
+    fn visit_binder(
+        mut self,
+        label: &'a L1,
+        subexpr: &'a SE1,
+    ) -> Result<(L2, SE2), Self::Error> {
+        Ok((
+            self.visit_label(label)?,
+            self.visit_subexpr_under_binder(label, subexpr)?,
+        ))
+    }
+
+    fn visit_embed_squash(
+        self,
+        embed: &'a E1,
+    ) -> Result<ExprF<SE2, L2, N2, E2>, Self::Error> {
+        Ok(ExprF::Embed(self.visit_embed(embed)?))
+    }
+
+    fn visit_note_squash(
+        mut self,
+        note: &'a N1,
+        subexpr: &'a SE1,
+    ) -> Result<ExprF<SE2, L2, N2, E2>, Self::Error> {
+        let subexpr = self.visit_subexpr(subexpr)?;
+        let note = self.visit_note(note)?;
+        Ok(ExprF::Note(note, subexpr))
+    }
+}
+
+impl<'a, T, SE1, SE2, L1, L2, N1, N2, E1, E2>
+    ExprFVeryGenericVisitor<'a, ExprF<SE2, L2, N2, E2>, SE1, L1, N1, E1> for T
+where
+    T: ExprFFallibleVisitor<'a, SE1, SE2, L1, L2, N1, N2, E1, E2>,
+{
+    type Error = T::Error;
+    type SE2 = SE2;
+    type L2 = L2;
+    type N2 = N2;
+    type E2 = E2;
+
+    fn visit_subexpr(
+        &mut self,
+        subexpr: &'a SE1,
+    ) -> Result<Self::SE2, Self::Error> {
+        self.visit_subexpr(subexpr)
+    }
+
+    fn visit_label(&mut self, label: &'a L1) -> Result<Self::L2, Self::Error> {
+        self.visit_label(label)
+    }
+
+    fn visit_binder(
+        self,
+        label: &'a L1,
+        subexpr: &'a SE1,
+    ) -> Result<(Self::L2, Self::SE2), Self::Error> {
+        self.visit_binder(label, subexpr)
+    }
+
+    fn visit_embed_squash(
+        self,
+        embed: &'a E1,
+    ) -> Result<ExprF<SE2, L2, N2, E2>, Self::Error> {
+        self.visit_embed_squash(embed)
+    }
+
+    fn visit_note_squash(
+        self,
+        note: &'a N1,
+        subexpr: &'a SE1,
+    ) -> Result<ExprF<SE2, L2, N2, E2>, Self::Error> {
+        self.visit_note_squash(note, subexpr)
+    }
+
+    // Called with the result of the map, in the non-embed/note case.
+    // Useful to change the result type, and/or avoid some loss of info
+    fn visit_resulting_exprf(
+        result: ExprF<Self::SE2, Self::L2, Self::N2, Self::E2>,
+    ) -> Result<ExprF<SE2, L2, N2, E2>, Self::Error> {
+        Ok(result)
+    }
+}
+
 /// Like ExprFFallibleVisitor, but without the error handling.
 pub trait ExprFInFallibleVisitor<'a, SE1, SE2, L1, L2, N1, N2, E1, E2>:
     Sized
-- 
cgit v1.2.3


From 69267c7cc108a2f5db35c52a71afaa5be7be7355 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 18 Apr 2019 14:10:03 +0200
Subject: Avoid an unnecessary unroll()

---
 dhall_core/src/core.rs    |  4 +--
 dhall_core/src/visitor.rs | 75 ++++++++++++++++++++++++++++++++---------------
 2 files changed, 52 insertions(+), 27 deletions(-)

diff --git a/dhall_core/src/core.rs b/dhall_core/src/core.rs
index 7f9fd14..158abe1 100644
--- a/dhall_core/src/core.rs
+++ b/dhall_core/src/core.rs
@@ -408,9 +408,8 @@ impl<N, E> Expr<N, E> {
     ) -> SubExpr<N, E2>
     where
         N: Clone,
-        E2: Clone,
     {
-        rc(self.visit(&mut visitor::SquashEmbedVisitor(f)))
+        trivial_result(self.visit(&mut visitor::SquashEmbedVisitor(f)))
     }
 }
 
@@ -427,7 +426,6 @@ impl<N: Clone> Expr<N, X> {
     }
     pub fn embed_absurd<E>(&self) -> Expr<N, E> {
         self.visit(&mut visitor::EmbedAbsurdVisitor)
-        // self.visit(&mut visitor::SquashEmbedVisitor(|e| match *e {}))
     }
 }
 
diff --git a/dhall_core/src/visitor.rs b/dhall_core/src/visitor.rs
index dcd860e..c2b0d06 100644
--- a/dhall_core/src/visitor.rs
+++ b/dhall_core/src/visitor.rs
@@ -541,37 +541,64 @@ where
 
 pub struct SquashEmbedVisitor<F1>(pub F1);
 
-impl<'a, 'b, N, E, E2, F1>
-    ExprFInFallibleVisitor<
-        'a,
-        SubExpr<N, E>,
-        SubExpr<N, E2>,
-        Label,
-        Label,
-        N,
-        N,
-        E,
-        E2,
-    > for &'b mut SquashEmbedVisitor<F1>
+impl<'a, 'b, N, E1, E2, F1>
+    ExprFVeryGenericVisitor<'a, SubExpr<N, E2>, SubExpr<N, E1>, Label, N, E1>
+    for &'b mut SquashEmbedVisitor<F1>
 where
     N: Clone + 'a,
-    E2: Clone,
-    F1: FnMut(&E) -> SubExpr<N, E2>,
+    F1: FnMut(&E1) -> SubExpr<N, E2>,
 {
-    fn visit_subexpr(&mut self, subexpr: &'a SubExpr<N, E>) -> SubExpr<N, E2> {
-        rc(subexpr.as_ref().visit(&mut **self))
+    type Error = X;
+    type SE2 = SubExpr<N, E2>;
+    type L2 = Label;
+    type N2 = N;
+    type E2 = E2;
+
+    fn visit_subexpr(
+        &mut self,
+        subexpr: &'a SubExpr<N, E1>,
+    ) -> Result<Self::SE2, Self::Error> {
+        Ok(subexpr.as_ref().visit(&mut **self)?)
     }
-    fn visit_note(self, note: &'a N) -> N {
-        N::clone(note)
+
+    fn visit_label(
+        &mut self,
+        label: &'a Label,
+    ) -> Result<Self::L2, Self::Error> {
+        Ok(Label::clone(label))
     }
-    fn visit_embed(self, _: &'a E) -> E2 {
-        unreachable!()
+
+    fn visit_binder(
+        mut self,
+        label: &'a Label,
+        subexpr: &'a SubExpr<N, E1>,
+    ) -> Result<(Self::L2, Self::SE2), Self::Error> {
+        Ok((self.visit_label(label)?, self.visit_subexpr(subexpr)?))
     }
-    fn visit_embed_squash(self, embed: &'a E) -> Expr<N, E2> {
-        (self.0)(embed).unroll()
+
+    fn visit_embed_squash(
+        self,
+        embed: &'a E1,
+    ) -> Result<SubExpr<N, E2>, Self::Error> {
+        Ok((self.0)(embed))
     }
-    fn visit_label(&mut self, label: &'a Label) -> Label {
-        Label::clone(label)
+
+    fn visit_note_squash(
+        mut self,
+        note: &'a N,
+        subexpr: &'a SubExpr<N, E1>,
+    ) -> Result<SubExpr<N, E2>, Self::Error> {
+        let subexpr = self.visit_subexpr(subexpr)?;
+        let note = N::clone(note);
+        Ok(rc(ExprF::Note(note, subexpr)))
+    }
+
+    // Called with the result of the map, in the non-embed/note case.
+    // Useful to change the result type, and/or avoid some loss of info
+    fn visit_resulting_exprf(
+        result: ExprF<Self::SE2, Self::L2, Self::N2, Self::E2>,
+    ) -> Result<SubExpr<N, E2>, Self::Error> {
+        Ok(rc(result))
     }
 }
 
-- 
cgit v1.2.3


From 9474d4939db6f844285182fc15aad74f6aa18e21 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 18 Apr 2019 14:39:56 +0200
Subject: Remove more duplication

---
 dhall/src/expr.rs                |  2 +-
 dhall/src/imports.rs             |  8 ++---
 dhall/src/normalize.rs           | 18 +++++------
 dhall/src/traits/dynamic_type.rs |  2 +-
 dhall/src/typecheck.rs           |  6 ++--
 dhall_core/src/core.rs           | 66 +++++++++++++++++++++-------------------
 dhall_core/src/visitor.rs        | 30 ------------------
 dhall_generator/src/quote.rs     |  8 ++---
 8 files changed, 55 insertions(+), 85 deletions(-)

diff --git a/dhall/src/expr.rs b/dhall/src/expr.rs
index 7c62a33..5885359 100644
--- a/dhall/src/expr.rs
+++ b/dhall/src/expr.rs
@@ -98,7 +98,7 @@ impl<'a> From<SubExpr<X, X>> for SimpleType<'a> {
 #[doc(hidden)]
 impl<'a> From<Normalized<'a>> for Typed<'a> {
     fn from(x: Normalized<'a>) -> Typed<'a> {
-        Typed(x.0.absurd(), x.1, x.2)
+        Typed(x.0.embed_absurd(), x.1, x.2)
     }
 }
 
diff --git a/dhall/src/imports.rs b/dhall/src/imports.rs
index b6dd80b..e367725 100644
--- a/dhall/src/imports.rs
+++ b/dhall/src/imports.rs
@@ -98,8 +98,8 @@ fn do_resolve_expr<'a>(
                 }
             }
         };
-    let expr = expr.as_ref().traverse_embed(resolve)?;
-    Ok(Resolved(rc(expr)))
+    let expr = expr.traverse_embed(resolve)?;
+    Ok(Resolved(expr))
 }
 
 fn skip_resolve_expr(
@@ -109,8 +109,8 @@ fn skip_resolve_expr(
         |import: &Import| -> Result<Normalized<'static>, ImportError> {
             Err(ImportError::UnexpectedImport(import.clone()))
         };
-    let expr = expr.as_ref().traverse_embed(&resolve)?;
-    Ok(Resolved(rc(expr)))
+    let expr = expr.traverse_embed(resolve)?;
+    Ok(Resolved(expr))
 }
 
 impl<'a> Parsed<'a> {
diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index 9110624..a54e48e 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -325,19 +325,17 @@ fn normalize_ref(expr: &Expr<X, Normalized<'static>>) -> Expr<X, X> {
     };
 
     match what_next {
-        Continue(e) => normalize_ref(&e.absurd_rec()),
-        ContinueSub(e) => normalize_ref(e.absurd().as_ref()),
+        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 => match expr.map_ref_simple(ExprF::roll) {
-            e => e.map_ref(
-                SubExpr::clone,
-                X::clone,
-                |_| unreachable!(),
-                Label::clone,
-            ),
-        },
+        DoneAsIs => expr.map_ref_simple(ExprF::roll).map_ref(
+            SubExpr::clone,
+            X::clone,
+            |_| unreachable!(),
+            Label::clone,
+        ),
     }
 }
 
diff --git a/dhall/src/traits/dynamic_type.rs b/dhall/src/traits/dynamic_type.rs
index d2a5414..d4faf45 100644
--- a/dhall/src/traits/dynamic_type.rs
+++ b/dhall/src/traits/dynamic_type.rs
@@ -35,7 +35,7 @@ impl<'a> DynamicType for Normalized<'a> {
             Some(t) => Ok(Cow::Borrowed(t)),
             None => Err(TypeError::new(
                 &Context::new(),
-                self.0.absurd(),
+                self.0.embed_absurd(),
                 TypeMessage::Untyped,
             )),
         }
diff --git a/dhall/src/typecheck.rs b/dhall/src/typecheck.rs
index de3899c..5aaeb08 100644
--- a/dhall/src/typecheck.rs
+++ b/dhall/src/typecheck.rs
@@ -496,7 +496,7 @@ fn type_last_layer(
                         PhantomData
                     )))
                 );
-                let tx = mktype(ctx, tx.absurd())?;
+                let tx = mktype(ctx, tx.embed_absurd())?;
                 ensure_equal!(&tx, a.get_type()?, {
                     let a = a.clone();
                     mkerr(TypeMismatch(
@@ -511,7 +511,7 @@ fn type_last_layer(
                         x.clone(),
                         None,
                         a.clone().normalize().embed(),
-                        tb.absurd(),
+                        tb.embed_absurd(),
                     )),
                 )?;
             }
@@ -675,7 +675,7 @@ fn type_last_layer(
         }
         Field(r, x) => match r.get_type()?.unroll_ref()?.as_ref() {
             RecordType(kts) => match kts.get(&x) {
-                Some(t) => Ok(RetExpr(t.unroll().absurd_rec())),
+                Some(t) => Ok(RetExpr(t.unroll().embed_absurd())),
                 None => Err(mkerr(MissingRecordField(x, r))),
             },
             _ => {
diff --git a/dhall_core/src/core.rs b/dhall_core/src/core.rs
index 158abe1..65762f2 100644
--- a/dhall_core/src/core.rs
+++ b/dhall_core/src/core.rs
@@ -205,14 +205,14 @@ pub enum ExprF<SubExpr, Label, Note, Embed> {
 }
 
 impl<SE, L, N, E> ExprF<SE, L, N, E> {
-    pub fn visit<'a, V, Return>(&'a self, v: V) -> Return
+    pub(crate) fn visit<'a, V, Return>(&'a self, v: V) -> Return
     where
         V: visitor::GenericVisitor<&'a ExprF<SE, L, N, E>, Return>,
     {
         v.visit(self)
     }
 
-    pub fn traverse_ref_with_special_handling_of_binders<
+    fn traverse_ref_with_special_handling_of_binders<
         'a,
         SE2,
         L2,
@@ -250,7 +250,7 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
         })
     }
 
-    pub fn traverse_ref<'a, SE2, L2, N2, E2, Err, F1, F3, F4, F5>(
+    fn traverse_ref<'a, SE2, L2, N2, E2, Err, F1, F3, F4, F5>(
         &'a self,
         visit_subexpr: F1,
         visit_note: F3,
@@ -343,7 +343,12 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
         E: Clone,
         F1: FnMut(&'a SE) -> Result<SE2, Err>,
     {
-        self.visit(visitor::TraverseRefSimpleVisitor { visit_subexpr })
+        self.traverse_ref(
+            visit_subexpr,
+            |x| Ok(N::clone(x)),
+            |x| Ok(E::clone(x)),
+            |x| Ok(L::clone(x)),
+        )
     }
 
     pub fn map_ref_simple<'a, SE2, F1>(
@@ -351,49 +356,35 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
         map_subexpr: F1,
     ) -> ExprF<SE2, L, N, E>
     where
-        L: Ord,
-        L: Clone,
+        L: Ord + Clone,
         N: Clone,
         E: Clone,
         F1: Fn(&'a SE) -> SE2,
     {
-        trivial_result(self.traverse_ref_simple(|x| Ok(map_subexpr(x))))
+        self.map_ref(map_subexpr, N::clone, E::clone, L::clone)
     }
 }
 
 impl<N, E> Expr<N, E> {
-    pub fn traverse_embed<E2, Err, F>(
+    fn traverse_embed<E2, Err, F>(
         &self,
-        map_embed: F,
+        visit_embed: F,
     ) -> Result<Expr<N, E2>, Err>
     where
         N: Clone,
         F: FnMut(&E) -> Result<E2, Err>,
     {
-        self.visit(&mut visitor::TraverseEmbedVisitor(map_embed))
+        self.visit(&mut visitor::TraverseEmbedVisitor(visit_embed))
     }
 
-    pub fn map_embed<E2, F>(&self, mut map_embed: F) -> Expr<N, E2>
+    fn map_embed<E2, F>(&self, mut map_embed: F) -> Expr<N, E2>
     where
-        E: Clone,
         N: Clone,
         F: FnMut(&E) -> E2,
     {
         trivial_result(self.traverse_embed(|x| Ok(map_embed(x))))
     }
 
-    pub fn map_label<F>(&self, map_label: &F) -> Self
-    where
-        E: Clone,
-        N: Clone,
-        F: Fn(&Label) -> Label,
-    {
-        let recurse = |e: &SubExpr<N, E>| -> SubExpr<N, E> {
-            rc(e.as_ref().map_label(map_label))
-        };
-        self.map_ref(recurse, N::clone, E::clone, map_label)
-    }
-
     pub fn roll(&self) -> SubExpr<N, E>
     where
         N: Clone,
@@ -420,10 +411,6 @@ impl<E: Clone> Expr<X, E> {
 }
 
 impl<N: Clone> Expr<N, X> {
-    // Deprecated, use embed_absurd instead
-    pub fn absurd_rec<E>(&self) -> Expr<N, E> {
-        self.embed_absurd()
-    }
     pub fn embed_absurd<E>(&self) -> Expr<N, E> {
         self.visit(&mut visitor::EmbedAbsurdVisitor)
     }
@@ -434,6 +421,25 @@ impl<N, E> SubExpr<N, E> {
         self.0.as_ref()
     }
 
+    pub fn traverse_embed<E2, Err, F>(
+        &self,
+        visit_embed: F,
+    ) -> Result<SubExpr<N, E2>, Err>
+    where
+        N: Clone,
+        F: FnMut(&E) -> Result<E2, Err>,
+    {
+        Ok(rc(self.as_ref().traverse_embed(visit_embed)?))
+    }
+
+    pub fn map_embed<E2, F>(&self, map_embed: F) -> SubExpr<N, E2>
+    where
+        N: Clone,
+        F: FnMut(&E) -> E2,
+    {
+        rc(self.as_ref().map_embed(map_embed))
+    }
+
     pub fn map_subexprs_with_special_handling_of_binders<'a, F1, F2>(
         &'a self,
         map_expr: F1,
@@ -480,10 +486,6 @@ impl<N, E> SubExpr<N, E> {
 }
 
 impl<N: Clone> SubExpr<N, X> {
-    // Deprecated, use embed_absurd instead
-    pub fn absurd<T>(&self) -> SubExpr<N, T> {
-        self.embed_absurd()
-    }
     pub fn embed_absurd<T>(&self) -> SubExpr<N, T> {
         rc(self.as_ref().embed_absurd())
     }
diff --git a/dhall_core/src/visitor.rs b/dhall_core/src/visitor.rs
index c2b0d06..16ad418 100644
--- a/dhall_core/src/visitor.rs
+++ b/dhall_core/src/visitor.rs
@@ -472,36 +472,6 @@ where
     }
 }
 
-pub struct TraverseRefSimpleVisitor<F1> {
-    pub visit_subexpr: F1,
-}
-
-impl<'a, SE, L, N, E, SE2, Err, F1>
-    ExprFFallibleVisitor<'a, SE, SE2, L, L, N, N, E, E>
-    for TraverseRefSimpleVisitor<F1>
-where
-    SE: 'a,
-    L: Ord + Clone + 'a,
-    N: Clone + 'a,
-    E: Clone + 'a,
-    F1: FnMut(&'a SE) -> Result<SE2, Err>,
-{
-    type Error = Err;
-
-    fn visit_subexpr(&mut self, subexpr: &'a SE) -> Result<SE2, Self::Error> {
-        (self.visit_subexpr)(subexpr)
-    }
-    fn visit_note(self, note: &'a N) -> Result<N, Self::Error> {
-        Ok(N::clone(note))
-    }
-    fn visit_embed(self, embed: &'a E) -> Result<E, Self::Error> {
-        Ok(E::clone(embed))
-    }
-    fn visit_label(&mut self, label: &'a L) -> Result<L, Self::Error> {
-        Ok(L::clone(label))
-    }
-}
-
 pub struct TraverseEmbedVisitor<F1>(pub F1);
 
 impl<'a, 'b, N, E, E2, Err, F1>
diff --git a/dhall_generator/src/quote.rs b/dhall_generator/src/quote.rs
index d680288..400c12c 100644
--- a/dhall_generator/src/quote.rs
+++ b/dhall_generator/src/quote.rs
@@ -10,8 +10,8 @@ pub fn expr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let expr: SubExpr<_, Import> = parse_expr(&input_str).unwrap().unnote();
     let no_import =
         |_: &Import| -> X { panic!("Don't use import in dhall::expr!()") };
-    let expr = expr.as_ref().map_embed(no_import);
-    let output = quote_expr(&expr, &Context::new());
+    let expr = expr.map_embed(no_import);
+    let output = quote_expr(&expr.unroll(), &Context::new());
     output.into()
 }
 
@@ -20,8 +20,8 @@ pub fn subexpr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let expr: SubExpr<_, Import> = parse_expr(&input_str).unwrap().unnote();
     let no_import =
         |_: &Import| -> X { panic!("Don't use import in dhall::subexpr!()") };
-    let expr = expr.as_ref().map_embed(no_import);
-    let output = quote_subexpr(&dhall_core::rc(expr), &Context::new());
+    let expr = expr.map_embed(no_import);
+    let output = quote_subexpr(&expr, &Context::new());
     output.into()
 }
 
-- 
cgit v1.2.3


From a0458fa3824ac301c8d0c1d7091e10d1468cbf91 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 18 Apr 2019 15:18:57 +0200
Subject: Use argument-position impl trait for mapping functions

---
 dhall_core/src/core.rs | 126 +++++++++++++++----------------------------------
 1 file changed, 39 insertions(+), 87 deletions(-)

diff --git a/dhall_core/src/core.rs b/dhall_core/src/core.rs
index 65762f2..aeb6f23 100644
--- a/dhall_core/src/core.rs
+++ b/dhall_core/src/core.rs
@@ -212,34 +212,17 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
         v.visit(self)
     }
 
-    fn traverse_ref_with_special_handling_of_binders<
-        'a,
-        SE2,
-        L2,
-        N2,
-        E2,
-        Err,
-        F1,
-        F2,
-        F3,
-        F4,
-        F5,
-    >(
+    fn traverse_ref_with_special_handling_of_binders<'a, SE2, L2, N2, E2, Err>(
         &'a self,
-        visit_subexpr: F1,
-        visit_under_binder: F2,
-        visit_note: F3,
-        visit_embed: F4,
-        visit_label: F5,
+        visit_subexpr: impl FnMut(&'a SE) -> Result<SE2, Err>,
+        visit_under_binder: impl FnOnce(&'a L, &'a SE) -> Result<SE2, Err>,
+        visit_note: impl FnOnce(&'a N) -> Result<N2, Err>,
+        visit_embed: impl FnOnce(&'a E) -> Result<E2, Err>,
+        visit_label: impl FnMut(&'a L) -> Result<L2, Err>,
     ) -> Result<ExprF<SE2, L2, N2, E2>, Err>
     where
         L: Ord,
         L2: Ord,
-        F1: FnMut(&'a SE) -> Result<SE2, Err>,
-        F2: FnOnce(&'a L, &'a SE) -> Result<SE2, Err>,
-        F3: FnOnce(&'a N) -> Result<N2, Err>,
-        F4: FnOnce(&'a E) -> Result<E2, Err>,
-        F5: FnMut(&'a L) -> Result<L2, Err>,
     {
         self.visit(visitor::TraverseRefWithBindersVisitor {
             visit_subexpr,
@@ -250,20 +233,16 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
         })
     }
 
-    fn traverse_ref<'a, SE2, L2, N2, E2, Err, F1, F3, F4, F5>(
+    fn traverse_ref<'a, SE2, L2, N2, E2, Err>(
         &'a self,
-        visit_subexpr: F1,
-        visit_note: F3,
-        visit_embed: F4,
-        visit_label: F5,
+        visit_subexpr: impl FnMut(&'a SE) -> Result<SE2, Err>,
+        visit_note: impl FnOnce(&'a N) -> Result<N2, Err>,
+        visit_embed: impl FnOnce(&'a E) -> Result<E2, Err>,
+        visit_label: impl FnMut(&'a L) -> Result<L2, Err>,
     ) -> Result<ExprF<SE2, L2, N2, E2>, Err>
     where
         L: Ord,
         L2: Ord,
-        F1: FnMut(&'a SE) -> Result<SE2, Err>,
-        F3: FnOnce(&'a N) -> Result<N2, Err>,
-        F4: FnOnce(&'a E) -> Result<E2, Err>,
-        F5: FnMut(&'a L) -> Result<L2, Err>,
     {
         self.visit(visitor::TraverseRefVisitor {
             visit_subexpr,
@@ -273,33 +252,17 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
         })
     }
 
-    pub fn map_ref_with_special_handling_of_binders<
-        'a,
-        SE2,
-        L2,
-        N2,
-        E2,
-        F1,
-        F2,
-        F3,
-        F4,
-        F5,
-    >(
+    pub fn map_ref_with_special_handling_of_binders<'a, SE2, L2, N2, E2>(
         &'a self,
-        mut map_subexpr: F1,
-        mut map_under_binder: F2,
-        map_note: F3,
-        map_embed: F4,
-        mut map_label: F5,
+        mut map_subexpr: impl FnMut(&'a SE) -> SE2,
+        mut map_under_binder: impl FnMut(&'a L, &'a SE) -> SE2,
+        map_note: impl FnOnce(&'a N) -> N2,
+        map_embed: impl FnOnce(&'a E) -> E2,
+        mut map_label: impl FnMut(&'a L) -> L2,
     ) -> ExprF<SE2, L2, N2, E2>
     where
         L: Ord,
         L2: Ord,
-        F1: FnMut(&'a SE) -> SE2,
-        F2: FnMut(&'a L, &'a SE) -> SE2,
-        F3: FnOnce(&'a N) -> N2,
-        F4: FnOnce(&'a E) -> E2,
-        F5: FnMut(&'a L) -> L2,
     {
         trivial_result(self.traverse_ref_with_special_handling_of_binders(
             |x| Ok(map_subexpr(x)),
@@ -310,20 +273,16 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
         ))
     }
 
-    pub fn map_ref<'a, SE2, L2, N2, E2, F1, F3, F4, F5>(
+    pub fn map_ref<'a, SE2, L2, N2, E2>(
         &'a self,
-        mut map_subexpr: F1,
-        map_note: F3,
-        map_embed: F4,
-        mut map_label: F5,
+        mut map_subexpr: impl FnMut(&'a SE) -> SE2,
+        map_note: impl FnOnce(&'a N) -> N2,
+        map_embed: impl FnOnce(&'a E) -> E2,
+        mut map_label: impl FnMut(&'a L) -> L2,
     ) -> ExprF<SE2, L2, N2, E2>
     where
         L: Ord,
         L2: Ord,
-        F1: FnMut(&'a SE) -> SE2,
-        F3: FnOnce(&'a N) -> N2,
-        F4: FnOnce(&'a E) -> E2,
-        F5: FnMut(&'a L) -> L2,
     {
         trivial_result(self.traverse_ref(
             |x| Ok(map_subexpr(x)),
@@ -333,15 +292,14 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
         ))
     }
 
-    pub fn traverse_ref_simple<'a, SE2, Err, F1>(
+    pub fn traverse_ref_simple<'a, SE2, Err>(
         &'a self,
-        visit_subexpr: F1,
+        visit_subexpr: impl FnMut(&'a SE) -> Result<SE2, Err>,
     ) -> Result<ExprF<SE2, L, N, E>, Err>
     where
         L: Ord + Clone,
         N: Clone,
         E: Clone,
-        F1: FnMut(&'a SE) -> Result<SE2, Err>,
     {
         self.traverse_ref(
             visit_subexpr,
@@ -351,36 +309,33 @@ impl<SE, L, N, E> ExprF<SE, L, N, E> {
         )
     }
 
-    pub fn map_ref_simple<'a, SE2, F1>(
+    pub fn map_ref_simple<'a, SE2>(
         &'a self,
-        map_subexpr: F1,
+        map_subexpr: impl Fn(&'a SE) -> SE2,
     ) -> ExprF<SE2, L, N, E>
     where
         L: Ord + Clone,
         N: Clone,
         E: Clone,
-        F1: Fn(&'a SE) -> SE2,
     {
         self.map_ref(map_subexpr, N::clone, E::clone, L::clone)
     }
 }
 
 impl<N, E> Expr<N, E> {
-    fn traverse_embed<E2, Err, F>(
+    fn traverse_embed<E2, Err>(
         &self,
-        visit_embed: F,
+        visit_embed: impl FnMut(&E) -> Result<E2, Err>,
     ) -> Result<Expr<N, E2>, Err>
     where
         N: Clone,
-        F: FnMut(&E) -> Result<E2, Err>,
     {
         self.visit(&mut visitor::TraverseEmbedVisitor(visit_embed))
     }
 
-    fn map_embed<E2, F>(&self, mut map_embed: F) -> Expr<N, E2>
+    fn map_embed<E2>(&self, mut map_embed: impl FnMut(&E) -> E2) -> Expr<N, E2>
     where
         N: Clone,
-        F: FnMut(&E) -> E2,
     {
         trivial_result(self.traverse_embed(|x| Ok(map_embed(x))))
     }
@@ -421,34 +376,31 @@ impl<N, E> SubExpr<N, E> {
         self.0.as_ref()
     }
 
-    pub fn traverse_embed<E2, Err, F>(
+    pub fn traverse_embed<E2, Err>(
         &self,
-        visit_embed: F,
+        visit_embed: impl FnMut(&E) -> Result<E2, Err>,
     ) -> Result<SubExpr<N, E2>, Err>
     where
         N: Clone,
-        F: FnMut(&E) -> Result<E2, Err>,
     {
         Ok(rc(self.as_ref().traverse_embed(visit_embed)?))
     }
 
-    pub fn map_embed<E2, F>(&self, map_embed: F) -> SubExpr<N, E2>
+    pub fn map_embed<E2>(
+        &self,
+        map_embed: impl FnMut(&E) -> E2,
+    ) -> SubExpr<N, E2>
     where
         N: Clone,
-        F: FnMut(&E) -> E2,
     {
         rc(self.as_ref().map_embed(map_embed))
     }
 
-    pub fn map_subexprs_with_special_handling_of_binders<'a, F1, F2>(
+    pub fn map_subexprs_with_special_handling_of_binders<'a>(
         &'a self,
-        map_expr: F1,
-        map_under_binder: F2,
-    ) -> Self
-    where
-        F1: FnMut(&'a Self) -> Self,
-        F2: FnMut(&'a Label, &'a Self) -> Self,
-    {
+        map_expr: impl FnMut(&'a Self) -> Self,
+        map_under_binder: impl FnMut(&'a Label, &'a Self) -> Self,
+    ) -> Self {
         match self.as_ref() {
             ExprF::Embed(_) => SubExpr::clone(self),
             // Recursive call
-- 
cgit v1.2.3