Custom Debug impls to improve debug legibility

2 files changed, 37 insertions, 3 deletions

diff --git a/dhall/src/core/thunk.rs b/dhall/src/core/thunk.rs
index 7c5c537..14d8792 100644
--- a/dhall/src/core/thunk.rs
+++ b/dhall/src/core/thunk.rs
@@ -39,7 +39,7 @@ enum ThunkInternal {
 /// Stores a possibly unevaluated value. Gets (partially) normalized on-demand,
 /// sharing computation automatically.
 /// Uses a RefCell to share computation.
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct Thunk(Rc<RefCell<ThunkInternal>>);
 
 /// A thunk in type position. Can optionally store a Type from the typechecking phase to preserve
@@ -393,3 +393,22 @@ impl std::cmp::PartialEq for TypedThunk {
     }
 }
 impl std::cmp::Eq for TypedThunk {}
+
+impl std::fmt::Debug for Thunk {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let b: &ThunkInternal = &self.0.borrow();
+        match b {
+            ThunkInternal::Value(m, v) => {
+                f.debug_tuple(&format!("Thunk@{:?}", m)).field(v).finish()
+            }
+            ThunkInternal::PartialExpr(e) => {
+                f.debug_tuple("Thunk@PartialExpr").field(e).finish()
+            }
+            ThunkInternal::Unnormalized(ctx, e) => f
+                .debug_tuple("Thunk@Unnormalized")
+                .field(ctx)
+                .field(e)
+                .finish(),
+        }
+    }
+}
diff --git a/dhall/src/core/var.rs b/dhall/src/core/var.rs
index 0faa091..d53c194 100644
--- a/dhall/src/core/var.rs
+++ b/dhall/src/core/var.rs
@@ -5,7 +5,7 @@ use dhall_syntax::{Label, V};
 /// Stores a pair of variables: a normal one and if relevant one
 /// that corresponds to the alpha-normalized version of the first one.
 /// Equality is up to alpha-equivalence.
-#[derive(Debug, Clone, Eq)]
+#[derive(Clone, Eq)]
 pub struct AlphaVar {
     normal: V<Label>,
     alpha: Option<V<()>>,
@@ -13,7 +13,7 @@ pub struct AlphaVar {
 
 // Exactly like a Label, but equality returns always true.
 // This is so that Value equality is exactly alpha-equivalence.
-#[derive(Debug, Clone, Eq)]
+#[derive(Clone, Eq)]
 pub struct AlphaLabel(Label);
 
 pub trait Shift: Sized {
@@ -125,6 +125,21 @@ impl std::cmp::PartialEq for AlphaLabel {
     }
 }
 
+impl std::fmt::Debug for AlphaVar {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.alpha {
+            Some(a) => write!(f, "AlphaVar({}, {})", self.normal, a.1),
+            None => write!(f, "AlphaVar({}, free)", self.normal),
+        }
+    }
+}
+
+impl std::fmt::Debug for AlphaLabel {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "AlphaLabel({})", &self.0)
+    }
+}
+
 impl From<Label> for AlphaVar {
     fn from(x: Label) -> AlphaVar {
         AlphaVar {