Implement missing traits

src/iterator.rs

@@ -1,6 +1,7 @@
 use crate::private::Entry;
 
 /// Read-only iterator to access all occupied slots.
+#[derive(Debug)]
 pub struct Iter<'a, IT> {
     inner: core::slice::Iter<'a, Entry<IT>>,
 }
@@ -26,7 +27,24 @@ impl<'a, IT> Iterator for Iter<'a, IT> {
     }
 }
 
+impl<IT> Clone for Iter<'_, IT> {
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl<IT> Default for Iter<'_, IT> {
+    fn default() -> Self {
+        Self {
+            inner: Default::default(),
+        }
+    }
+}
+
 /// Read-write iterator to access all occupied slots.
+#[derive(Debug)]
 pub struct IterMut<'a, IT> {
     inner: core::slice::IterMut<'a, Entry<IT>>,
 }
@@ -52,6 +70,14 @@ impl<'a, IT> Iterator for IterMut<'a, IT> {
     }
 }
 
+impl<IT> Default for IterMut<'_, IT> {
+    fn default() -> Self {
+        Self {
+            inner: Default::default(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod iter_test {
     use crate::{slots::Slots, unrestricted::UnrestrictedSlots};

src/private.rs

@@ -2,6 +2,7 @@
 //! that are conceptually private but must be technically public.
 
 #[doc(hidden)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 pub enum Entry<IT> {
     Used(IT),
     EmptyNext(usize),

src/slots.rs

@@ -131,6 +131,51 @@ pub struct Key<IT, const N: usize> {
     _item_marker: PhantomData<IT>,
 }
 
+impl<IT, const N: usize> Clone for Key<IT, N> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<IT, const N: usize> Copy for Key<IT, N> {}
+
+impl<IT, const N: usize> PartialEq for Key<IT, N> {
+    fn eq(&self, other: &Self) -> bool {
+        #[cfg(feature = "runtime_checks")]
+        let owner_id_partial_eq = self.owner_id == other.owner_id;
+        #[cfg(not(feature = "runtime_checks"))]
+        let owner_id_partial_eq = true;
+        owner_id_partial_eq && self.index == other.index
+    }
+}
+
+impl<IT, const N: usize> Eq for Key<IT, N> {}
+
+impl<IT, const N: usize> PartialOrd for Key<IT, N> {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl<IT, const N: usize> Ord for Key<IT, N> {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+        #[cfg(feature = "runtime_checks")]
+        let owner_id_cmp = self.owner_id.cmp(&other.owner_id);
+        #[cfg(not(feature = "runtime_checks"))]
+        let owner_id_cmp = core::cmp::Ordering::Equal;
+        owner_id_cmp.then(self.index.cmp(&other.index))
+    }
+}
+
+impl<IT, const N: usize> core::hash::Hash for Key<IT, N> {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        #[cfg(feature = "runtime_checks")]
+        self.owner_id.hash(state);
+        self.index.hash(state);
+        self._item_marker.hash(state);
+    }
+}
+
 impl<IT, const N: usize> Key<IT, N> {
     fn new(owner: &Slots<IT, N>, idx: usize) -> Self {
         Self {
@@ -153,13 +198,19 @@ impl<IT, const N: usize> Key<IT, N> {
 ///  - `N` is the number of slots.
 ///
 /// For more information, see the [module level documentation](./index.html)
-#[derive(Default)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 pub struct Slots<IT, const N: usize> {
     #[cfg(feature = "runtime_checks")]
     id: usize,
     inner: UnrestrictedSlots<IT, N>,
 }
 
+impl<IT, const N: usize> Default for Slots<IT, N> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 #[cfg(feature = "runtime_checks")]
 fn new_instance_id() -> usize {
     use core::sync::atomic::{AtomicUsize, Ordering};

src/unrestricted.rs

@@ -52,6 +52,7 @@ use crate::private::Entry;
 ///  - `N` is the number of slots.
 ///
 /// For more information, see the [module level documentation](crate::unrestricted)
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 pub struct UnrestrictedSlots<IT, const N: usize> {
     items: [Entry<IT>; N],
     next_free: usize,