From 58339a2e5800f28cb6963d5c90cac20637f9b8ef Mon Sep 17 00:00:00 2001
From: Kacy Fortner <kacy@kacyfortner.com>
Date: Sat, 14 Feb 2026 12:06:44 -0500
Subject: [PATCH] refactor: replace unreachable!() with let-else, reduce
 sorted_set cloning

keyspace.rs:
- list_push: use let-else to destructure Value::List, capture len before
  touch() instead of re-matching after mutation
- list_pop: replace expect("verified above") + unreachable!() with
  let-else pattern that eliminates the double HashMap lookup
- hincrby: replace unreachable!() else branch with let-else that returns
  a proper error

sorted_set.rs:
- add_with_flags: reorder tree/scores inserts so the member is cloned
  once (into scores) then moved (into tree), instead of cloning twice
---
 crates/ember-core/src/keyspace.rs         | 74 ++++++++++-------------
 crates/ember-core/src/types/sorted_set.rs |  8 +--
 2 files changed, 37 insertions(+), 45 deletions(-)

diff --git a/crates/ember-core/src/keyspace.rs b/crates/ember-core/src/keyspace.rs
index dfdf1671..f50a612d 100644
--- a/crates/ember-core/src/keyspace.rs
+++ b/crates/ember-core/src/keyspace.rs
@@ -1096,24 +1096,22 @@ impl Keyspace {
             .expect("just inserted or verified");
         let old_entry_size = memory::entry_size(key, &entry.value);
 
-        if let Value::List(ref mut deque) = entry.value {
-            for val in values {
-                if left {
-                    deque.push_front(val.clone());
-                } else {
-                    deque.push_back(val.clone());
-                }
+        let Value::List(ref mut deque) = entry.value else {
+            return Err(WriteError::WrongType);
+        };
+        for val in values {
+            if left {
+                deque.push_front(val.clone());
+            } else {
+                deque.push_back(val.clone());
             }
         }
+        let len = deque.len();
         entry.touch();
 
         let new_entry_size = memory::entry_size(key, &entry.value);
         self.memory.adjust(old_entry_size, new_entry_size);
 
-        let len = match &entry.value {
-            Value::List(d) => d.len(),
-            _ => unreachable!(),
-        };
         Ok(len)
     }
 
@@ -1123,25 +1121,22 @@ impl Keyspace {
             return Ok(None);
         }
 
-        match self.entries.get(key) {
-            None => return Ok(None),
-            Some(e) => {
-                if !matches!(e.value, Value::List(_)) {
-                    return Err(WrongType);
-                }
-            }
+        let Some(entry) = self.entries.get_mut(key) else {
+            return Ok(None);
         };
+        if !matches!(entry.value, Value::List(_)) {
+            return Err(WrongType);
+        }
 
-        let old_entry_size = memory::entry_size(key, &self.entries[key].value);
-        let entry = self.entries.get_mut(key).expect("verified above");
-        let popped = if let Value::List(ref mut deque) = entry.value {
-            if left {
-                deque.pop_front()
-            } else {
-                deque.pop_back()
-            }
+        let old_entry_size = memory::entry_size(key, &entry.value);
+        let Value::List(ref mut deque) = entry.value else {
+            // checked above
+            return Err(WrongType);
+        };
+        let popped = if left {
+            deque.pop_front()
         } else {
-            unreachable!()
+            deque.pop_back()
         };
         entry.touch();
 
@@ -1576,21 +1571,18 @@ impl Keyspace {
             .expect("just inserted or verified");
         let old_entry_size = memory::entry_size(key, &entry.value);
 
-        let new_val = if let Value::Hash(ref mut map) = entry.value {
-            let current_val = match map.get(field) {
-                Some(data) => {
-                    let s = std::str::from_utf8(data).map_err(|_| IncrError::NotAnInteger)?;
-                    s.parse::<i64>().map_err(|_| IncrError::NotAnInteger)?
-                }
-                None => 0,
-            };
-
-            let new_val = current_val.checked_add(delta).ok_or(IncrError::Overflow)?;
-            map.insert(field.to_owned(), Bytes::from(new_val.to_string()));
-            new_val
-        } else {
-            unreachable!()
+        let Value::Hash(ref mut map) = entry.value else {
+            return Err(IncrError::WrongType);
+        };
+        let current_val = match map.get(field) {
+            Some(data) => {
+                let s = std::str::from_utf8(data).map_err(|_| IncrError::NotAnInteger)?;
+                s.parse::<i64>().map_err(|_| IncrError::NotAnInteger)?
+            }
+            None => 0,
         };
+        let new_val = current_val.checked_add(delta).ok_or(IncrError::Overflow)?;
+        map.insert(field.to_owned(), Bytes::from(new_val.to_string()));
         entry.touch();
 
         let new_entry_size = memory::entry_size(key, &entry.value);
diff --git a/crates/ember-core/src/types/sorted_set.rs b/crates/ember-core/src/types/sorted_set.rs
index ada36a46..9cd5f610 100644
--- a/crates/ember-core/src/types/sorted_set.rs
+++ b/crates/ember-core/src/types/sorted_set.rs
@@ -96,8 +96,8 @@ impl SortedSet {
             }
             // update: remove old entry, insert new
             self.tree.remove(&(old_score, member.clone()));
-            self.tree.insert((new_score, member.clone()), ());
-            self.scores.insert(member, new_score);
+            self.scores.insert(member.clone(), new_score);
+            self.tree.insert((new_score, member), ());
             AddResult {
                 added: false,
                 updated: true,
@@ -110,8 +110,8 @@ impl SortedSet {
                     updated: false,
                 };
             }
-            self.tree.insert((new_score, member.clone()), ());
-            self.scores.insert(member, new_score);
+            self.scores.insert(member.clone(), new_score);
+            self.tree.insert((new_score, member), ());
             AddResult {
                 added: true,
                 updated: false,