style: return Result instead of Option

Author: morrisonlevi

src/raw/mod.rs

@@ -1092,10 +1092,12 @@ impl<T, A: Allocator> RawTable<T, A> {
     ///
     /// This does not check if the given element already exists in the table.
     #[inline]
-    pub(crate) fn insert_within_capacity(&mut self, hash: u64, value: T) -> Option<Bucket<T>> {
-        let slot = self.find_insert_slot(hash)?;
-        // SAFETY: todo
-        Some(unsafe { self.insert_in_slot(hash, slot, value) })
+    pub(crate) fn insert_within_capacity(&mut self, hash: u64, value: T) -> Result<Bucket<T>, T> {
+        match self.find_insert_slot(hash) {
+            // SAFETY: todo
+            Some(slot) => Ok(unsafe { self.insert_in_slot(hash, slot, value) }),
+            None => Err(value),
+        }
     }
 
     /// Inserts a new element into the table, and returns a mutable reference to it.

src/table.rs

@@ -417,7 +417,8 @@ where
 
     /// Inserts an element into the `HashTable` with the given hash value, but
     /// without checking whether an equivalent element already exists within
-    /// the table. If there is insufficient capacity, then this returns None.
+    /// the table. If there is insufficient capacity, then this returns an
+    /// error holding the provided value.
     ///
     /// # Examples
     ///
@@ -430,9 +431,10 @@ where
     /// let mut v = HashTable::new();
     /// let hasher = DefaultHashBuilder::default();
     /// let hasher = |val: &_| hasher.hash_one(val);
-    /// assert!(v.insert_unique_within_capacity(hasher(&1), 1).is_none());
+    /// assert!(v.insert_unique_within_capacity(hasher(&1), 1).is_err());
+    /// assert!(v.is_empty());
     /// v.reserve(1, hasher);
-    /// v.insert_unique_within_capacity(hasher(&1), 1);
+    /// assert!(v.insert_unique_within_capacity(hasher(&1), 1).is_ok());
     /// assert!(!v.is_empty());
     /// # }
     /// # fn main() {
@@ -444,13 +446,15 @@ where
         &mut self,
         hash: u64,
         value: T,
-    ) -> Option<OccupiedEntry<'_, T, A>> {
-        let bucket = self.raw.insert_within_capacity(hash, value)?;
-        Some(OccupiedEntry {
-            hash,
-            bucket,
-            table: self,
-        })
+    ) -> Result<OccupiedEntry<'_, T, A>, T> {
+        match self.raw.insert_within_capacity(hash, value) {
+            Some(bucket) => Ok(OccupiedEntry {
+                hash,
+                bucket,
+                table: self,
+            }),
+            None => Err(value),
+        }
     }
 
     /// Clears the table, removing all values.