Clean up backing_store

Moves over some changes in #124 to keep things clean!

- removes duplicate `UniqueTable`
- reverts `backing_store::UniqueTable` to only have `get_or_insert` as part of its interface; move the other methods to just `BackedRobinhoodTable`
- tidies up trait bounds (`Eq` implies `PartialEq`, `Debug` is no longer needed)
- removes unneeded size check in `get_by_hash`

src/backing_store/bump_table.rs

@@ -158,16 +158,23 @@ where
     }
 }
 
-impl<'a, T: Eq + PartialEq + Hash + Clone + std::fmt::Debug> UniqueTable<'a, T>
-    for BackedRobinhoodTable<'a, T>
-{
+impl<'a, T: Eq + Hash + Clone> UniqueTable<'a, T> for BackedRobinhoodTable<'a, T> {
     fn get_or_insert(&'a mut self, elem: T) -> &'a T {
         let mut hasher = FxHasher::default();
         elem.hash(&mut hasher);
         let hash = hasher.finish();
         self.get_or_insert_by_hash(hash, elem, false)
     }
-    fn get_or_insert_by_hash(&'a mut self, hash: u64, elem: T, equality_by_hash: bool) -> &'a T {
+}
+
+impl<'a, T: Eq + Hash + Clone> BackedRobinhoodTable<'a, T> {
+    /// use a hash to both allocate space in table, *and* form equalitySS
+    pub fn get_or_insert_by_hash(
+        &'a mut self,
+        hash: u64,
+        elem: T,
+        equality_by_hash: bool,
+    ) -> &'a T {
         if (self.len + 1) as f64 > (self.cap as f64 * LOAD_FACTOR) {
             self.grow();
         }
@@ -215,11 +222,7 @@ impl<'a, T: Eq + PartialEq + Hash + Clone + std::fmt::Debug> UniqueTable<'a, T>
         }
     }
 
-    fn get_by_hash(&'a mut self, hash: u64) -> Option<&'a T> {
-        if (self.len + 1) as f64 > (self.cap as f64 * LOAD_FACTOR) {
-            self.grow();
-        }
-
+    pub fn get_by_hash(&'a mut self, hash: u64) -> Option<&'a T> {
         // the current index into the array
         let mut pos: usize = (hash as usize) % self.cap;
         // the distance this item is from its desired location
@@ -245,10 +248,7 @@ impl<'a, T: Eq + PartialEq + Hash + Clone + std::fmt::Debug> UniqueTable<'a, T>
     }
 }
 
-impl<'a, T: Clone> Default for BackedRobinhoodTable<'a, T>
-where
-    T: Hash + PartialEq + Eq + Clone,
-{
+impl<'a, T: Hash + Eq + Clone> Default for BackedRobinhoodTable<'a, T> {
     fn default() -> Self {
         Self::new()
     }

src/backing_store/mod.rs

@@ -3,10 +3,7 @@ pub mod bump_table;
 
 use std::hash::Hash;
 
-pub trait UniqueTable<'a, T: Eq + PartialEq + Hash> {
-    fn get_by_hash(&'a mut self, hash: u64) -> Option<&'a T>;
-    /// use a hash to allocate space in table, but use strict equality
+pub trait UniqueTable<'a, T: Eq + Hash> {
+    /// use a hash to allocate space in table, but use strict equality for probing/checking
     fn get_or_insert(&'a mut self, item: T) -> &'a T;
-    /// use a hash to both allocate space in table, *and* form equality
-    fn get_or_insert_by_hash(&'a mut self, hash: u64, item: T, equality_by_hash: bool) -> &'a T;
 }

src/builder/sdd/semantic.rs

@@ -5,7 +5,6 @@ use std::hash::{Hash, Hasher};
 use rustc_hash::FxHasher;
 
 use crate::backing_store::bump_table::BackedRobinhoodTable;
-use crate::backing_store::UniqueTable;
 use crate::builder::cache::ite::Ite;
 use crate::repr::bdd::create_semantic_hash_map;
 use crate::repr::ddnnf::DDNNFPtr;

src/lib.rs

@@ -22,7 +22,6 @@ pub mod plan;
 pub mod repr;
 pub mod sample;
 pub mod serialize;
-pub mod unique_table;
 
 #[cfg(target_arch = "wasm32")]
 pub mod wasm;