Add mapping functions to InterpolatedTextContents

3 files changed, 54 insertions, 26 deletions

diff --git a/dhall/src/core/valuef.rs b/dhall/src/core/valuef.rs
index 7a2b51c..4e457e6 100644
--- a/dhall/src/core/valuef.rs
+++ b/dhall/src/core/valuef.rs
@@ -110,17 +110,11 @@ impl ValueF {
                 ValueF::UnionConstructor(l.clone(), kts.clone()).to_expr(opts),
                 v.to_expr(opts),
             )),
-            ValueF::TextLit(elts) => {
-                use InterpolatedTextContents::{Expr, Text};
-                rc(ExprF::TextLit(
-                    elts.iter()
-                        .map(|contents| match contents {
-                            Expr(e) => Expr(e.to_expr(opts)),
-                            Text(s) => Text(s.clone()),
-                        })
-                        .collect(),
-                ))
-            }
+            ValueF::TextLit(elts) => rc(ExprF::TextLit(
+                elts.iter()
+                    .map(|contents| contents.map_ref(|e| e.to_expr(opts)))
+                    .collect(),
+            )),
             ValueF::Equivalence(x, y) => rc(ExprF::BinOp(
                 dhall_syntax::BinOp::Equivalence,
                 x.to_expr(opts),
@@ -187,11 +181,7 @@ impl ValueF {
             }
             ValueF::TextLit(elts) => {
                 for x in elts.iter_mut() {
-                    use InterpolatedTextContents::{Expr, Text};
-                    match x {
-                        Expr(v) => v.normalize_mut(),
-                        Text(_) => {}
-                    }
+                    x.map_mut(Value::normalize_mut);
                 }
             }
             ValueF::Equivalence(x, y) => {
diff --git a/dhall/src/core/var.rs b/dhall/src/core/var.rs
index ce4d137..3795f10 100644
--- a/dhall/src/core/var.rs
+++ b/dhall/src/core/var.rs
@@ -224,11 +224,7 @@ where
 
 impl<T: Shift> Shift for dhall_syntax::InterpolatedTextContents<T> {
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        use dhall_syntax::InterpolatedTextContents::{Expr, Text};
-        Some(match self {
-            Expr(x) => Expr(x.shift(delta, var)?),
-            Text(s) => Text(s.clone()),
-        })
+        Some(self.traverse_ref(|x| Ok(x.shift(delta, var)?))?)
     }
 }
 
@@ -283,11 +279,7 @@ impl<S, T: Subst<S>> Subst<S> for Vec<T> {
 
 impl<S, T: Subst<S>> Subst<S> for dhall_syntax::InterpolatedTextContents<T> {
     fn subst_shift(&self, var: &AlphaVar, val: &S) -> Self {
-        use dhall_syntax::InterpolatedTextContents::{Expr, Text};
-        match self {
-            Expr(x) => Expr(x.subst_shift(var, val)),
-            Text(s) => Text(s.clone()),
-        }
+        self.map_ref(|x| x.subst_shift(var, val))
     }
 }
 
diff --git a/dhall_syntax/src/core/text.rs b/dhall_syntax/src/core/text.rs
index e17f00f..fb390ee 100644
--- a/dhall_syntax/src/core/text.rs
+++ b/dhall_syntax/src/core/text.rs
@@ -40,6 +40,52 @@ impl<SubExpr> InterpolatedTextContents<SubExpr> {
             Text(s) => s.is_empty(),
         }
     }
+
+    pub fn traverse_ref<'a, SubExpr2, E, F>(
+        &'a self,
+        mut f: F,
+    ) -> Result<InterpolatedTextContents<SubExpr2>, E>
+    where
+        F: FnMut(&'a SubExpr) -> Result<SubExpr2, E>,
+    {
+        use InterpolatedTextContents::{Expr, Text};
+        Ok(match self {
+            Expr(e) => Expr(f(e)?),
+            Text(s) => Text(s.clone()),
+        })
+    }
+    pub fn traverse_mut<'a, E, F>(&'a mut self, mut f: F) -> Result<(), E>
+    where
+        F: FnMut(&'a mut SubExpr) -> Result<(), E>,
+    {
+        use InterpolatedTextContents::Expr;
+        if let Expr(e) = self {
+            f(e)?;
+        }
+        Ok(())
+    }
+    pub fn map_ref<'a, SubExpr2, F>(
+        &'a self,
+        mut f: F,
+    ) -> InterpolatedTextContents<SubExpr2>
+    where
+        F: FnMut(&'a SubExpr) -> SubExpr2,
+    {
+        use InterpolatedTextContents::{Expr, Text};
+        match self {
+            Expr(e) => Expr(f(e)),
+            Text(s) => Text(s.clone()),
+        }
+    }
+    pub fn map_mut<'a, F>(&'a mut self, mut f: F)
+    where
+        F: FnMut(&'a mut SubExpr),
+    {
+        use InterpolatedTextContents::Expr;
+        if let Expr(e) = self {
+            f(e);
+        }
+    }
 }
 
 impl<SubExpr> InterpolatedText<SubExpr> {