Manual Debug impls so we don't require S: Debug

Author: jonhoo

evmap/src/lib.rs

@@ -255,7 +255,6 @@ impl<V: ?Sized> fmt::Debug for Predicate<V> {
 
 /// A pending map operation.
 #[non_exhaustive]
-#[derive(PartialEq, Eq, Debug)]
 pub(crate) enum Operation<K, V, M> {
     /// Replace the set of entries for this key with this value.
     Replace(K, V),
@@ -297,6 +296,34 @@ pub(crate) enum Operation<K, V, M> {
     JustCloneRHandle,
 }
 
+impl<K, V, M> fmt::Debug for Operation<K, V, M>
+where
+    K: fmt::Debug,
+    V: fmt::Debug,
+    M: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Operation::Replace(ref a, ref b) => f.debug_tuple("Replace").field(a).field(b).finish(),
+            Operation::Add(ref a, ref b) => f.debug_tuple("Add").field(a).field(b).finish(),
+            Operation::RemoveValue(ref a, ref b) => {
+                f.debug_tuple("RemoveValue").field(a).field(b).finish()
+            }
+            Operation::RemoveEntry(ref a) => f.debug_tuple("RemoveEntry").field(a).finish(),
+            #[cfg(feature = "eviction")]
+            Operation::EmptyAt(ref a) => f.debug_tuple("EmptyAt").field(a).finish(),
+            Operation::Clear(ref a) => f.debug_tuple("Clear").field(a).finish(),
+            Operation::Purge => f.debug_tuple("Purge").finish(),
+            Operation::Retain(ref a, ref b) => f.debug_tuple("Retain").field(a).field(b).finish(),
+            Operation::Fit(ref a) => f.debug_tuple("Fit").field(a).finish(),
+            Operation::Reserve(ref a, ref b) => f.debug_tuple("Reserve").field(a).field(b).finish(),
+            Operation::MarkReady => f.debug_tuple("MarkReady").finish(),
+            Operation::SetMeta(ref a) => f.debug_tuple("SetMeta").field(a).finish(),
+            Operation::JustCloneRHandle => f.debug_tuple("JustCloneRHandle").finish(),
+        }
+    }
+}
+
 /// Options for how to initialize the map.
 ///
 /// In particular, the options dictate the hashing function, meta type, and initial capacity of the

evmap/src/read/read_ref.rs

@@ -2,6 +2,7 @@ use crate::{inner::Inner, values::Values};
 use left_right::ReadGuard;
 use std::borrow::Borrow;
 use std::collections::hash_map::RandomState;
+use std::fmt;
 use std::hash::{BuildHasher, Hash};
 
 // To make [`WriteHandle`] and friends work.
@@ -15,7 +16,6 @@ use crate::WriteHandle;
 ///
 /// Since the map remains immutable while this lives, the methods on this type all give you
 /// unguarded references to types contained in the map.
-#[derive(Debug)]
 pub struct MapReadRef<'rh, K, V, M = (), S = RandomState>
 where
     K: Hash + Eq,
@@ -25,6 +25,22 @@ where
     pub(super) guard: ReadGuard<'rh, Inner<K, V, M, S>>,
 }
 
+impl<'rh, K, V, M, S> fmt::Debug for MapReadRef<'rh, K, V, M, S>
+where
+    K: Hash + Eq,
+    V: Eq + Hash,
+    S: BuildHasher,
+    K: fmt::Debug,
+    M: fmt::Debug,
+    V: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapReadRef")
+            .field("guard", &self.guard)
+            .finish()
+    }
+}
+
 impl<'rh, K, V, M, S> MapReadRef<'rh, K, V, M, S>
 where
     K: Hash + Eq,
@@ -169,7 +185,6 @@ where
 }
 
 /// An [`Iterator`] over keys and values in the evmap.
-#[derive(Debug)]
 pub struct ReadGuardIter<'rg, K, V, S>
 where
     K: Eq + Hash,
@@ -179,6 +194,18 @@ where
     iter: <&'rg crate::inner::MapImpl<K, Values<V, S>, S> as IntoIterator>::IntoIter,
 }
 
+impl<'rg, K, V, S> fmt::Debug for ReadGuardIter<'rg, K, V, S>
+where
+    K: Eq + Hash + fmt::Debug,
+    V: Eq + Hash,
+    S: BuildHasher,
+    V: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("ReadGuardIter").field(&self.iter).finish()
+    }
+}
+
 impl<'rg, K, V, S> Iterator for ReadGuardIter<'rg, K, V, S>
 where
     K: Eq + Hash,
@@ -192,7 +219,6 @@ where
 }
 
 /// An [`Iterator`] over keys.
-#[derive(Debug)]
 pub struct KeysIter<'rg, K, V, S>
 where
     K: Eq + Hash,
@@ -202,6 +228,18 @@ where
     iter: <&'rg crate::inner::MapImpl<K, Values<V, S>, S> as IntoIterator>::IntoIter,
 }
 
+impl<'rg, K, V, S> fmt::Debug for KeysIter<'rg, K, V, S>
+where
+    K: Eq + Hash + fmt::Debug,
+    V: Eq + Hash,
+    S: BuildHasher,
+    V: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("KeysIter").field(&self.iter).finish()
+    }
+}
+
 impl<'rg, K, V, S> Iterator for KeysIter<'rg, K, V, S>
 where
     K: Eq + Hash,
@@ -215,7 +253,6 @@ where
 }
 
 /// An [`Iterator`] over value sets.
-#[derive(Debug)]
 pub struct ValuesIter<'rg, K, V, S>
 where
     K: Eq + Hash,
@@ -225,6 +262,18 @@ where
     iter: <&'rg crate::inner::MapImpl<K, Values<V, S>, S> as IntoIterator>::IntoIter,
 }
 
+impl<'rg, K, V, S> fmt::Debug for ValuesIter<'rg, K, V, S>
+where
+    K: Eq + Hash + fmt::Debug,
+    V: Eq + Hash,
+    S: BuildHasher,
+    V: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("ValuesIter").field(&self.iter).finish()
+    }
+}
+
 impl<'rg, K, V, S> Iterator for ValuesIter<'rg, K, V, S>
 where
     K: Eq + Hash,

evmap/src/values.rs

@@ -108,14 +108,25 @@ impl<'a, T, S> IntoIterator for &'a Values<T, S> {
     }
 }
 
-#[derive(Debug)]
 pub enum ValuesIter<'a, T, S> {
     #[doc(hidden)]
     Short(<&'a smallvec::SmallVec<[T; 1]> as IntoIterator>::IntoIter),
     #[doc(hidden)]
     Long(<&'a hashbag::HashBag<T, S> as IntoIterator>::IntoIter),
 }
 
+impl<'a, T, S> fmt::Debug for ValuesIter<'a, T, S>
+where
+    T: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            ValuesIter::Short(ref it) => f.debug_tuple("Short").field(it).finish(),
+            ValuesIter::Long(ref it) => f.debug_tuple("Long").field(it).finish(),
+        }
+    }
+}
+
 impl<'a, T, S> Iterator for ValuesIter<'a, T, S> {
     type Item = &'a T;
     fn next(&mut self) -> Option<Self::Item> {