Refactor conditional checks for improved readability in cache data structures

- Simplified conditional checks in `clock_ring.rs`, `frequency_buckets.rs`, and `ghost_list.rs` to enhance code clarity and maintainability.
- Updated the `pop_lfu_internal` method in `heap_lfu.rs` to improve the structure of the return condition, ensuring better readability while maintaining functionality.

Author: TKorr

src/ds/clock_ring.rs

@@ -393,10 +393,10 @@ where
         let cap = self.capacity();
         for offset in 0..cap {
             let idx = (self.hand + offset) % cap;
-            if let Some(entry) = self.slots.get(idx).and_then(|slot| slot.as_ref())
-                && !entry.referenced
-            {
-                return Some((&entry.key, &entry.value));
+            if let Some(entry) = self.slots.get(idx).and_then(|slot| slot.as_ref()) {
+                if !entry.referenced {
+                    return Some((&entry.key, &entry.value));
+                }
             }
         }
         None

src/ds/frequency_buckets.rs

@@ -710,28 +710,28 @@ where
         };
         self.buckets.insert(freq, bucket);
 
-        if let Some(prev) = prev
-            && let Some(prev_bucket) = self.buckets.get_mut(&prev)
-        {
-            prev_bucket.next = Some(freq);
+        if let Some(prev) = prev {
+            if let Some(prev_bucket) = self.buckets.get_mut(&prev) {
+                prev_bucket.next = Some(freq);
+            }
         }
-        if let Some(next) = next
-            && let Some(next_bucket) = self.buckets.get_mut(&next)
-        {
-            next_bucket.prev = Some(freq);
+        if let Some(next) = next {
+            if let Some(next_bucket) = self.buckets.get_mut(&next) {
+                next_bucket.prev = Some(freq);
+            }
         }
     }
 
     fn remove_bucket(&mut self, freq: u64, prev: Option<u64>, next: Option<u64>) {
-        if let Some(prev) = prev
-            && let Some(prev_bucket) = self.buckets.get_mut(&prev)
-        {
-            prev_bucket.next = next;
+        if let Some(prev) = prev {
+            if let Some(prev_bucket) = self.buckets.get_mut(&prev) {
+                prev_bucket.next = next;
+            }
         }
-        if let Some(next) = next
-            && let Some(next_bucket) = self.buckets.get_mut(&next)
-        {
-            next_bucket.prev = prev;
+        if let Some(next) = next {
+            if let Some(next_bucket) = self.buckets.get_mut(&next) {
+                next_bucket.prev = prev;
+            }
         }
         self.buckets.remove(&freq);
     }
@@ -1023,9 +1023,11 @@ where
         let mut best: Option<(usize, u64)> = None;
         for (idx, shard) in self.shards.iter().enumerate() {
             let buckets = shard.read();
-            if let Some(freq) = buckets.min_freq()
-                && best.is_none_or(|(_, best_freq)| freq < best_freq)
-            {
+            let Some(freq) = buckets.min_freq() else {
+                continue;
+            };
+            let is_better = best.is_none_or(|(_, best_freq)| freq < best_freq);
+            if is_better {
                 best = Some((idx, freq));
             }
         }
@@ -1039,9 +1041,11 @@ where
         let mut best: Option<(usize, u64)> = None;
         for (idx, shard) in self.shards.iter().enumerate() {
             let buckets = shard.read();
-            if let Some(freq) = buckets.min_freq()
-                && best.is_none_or(|(_, best_freq)| freq < best_freq)
-            {
+            let Some(freq) = buckets.min_freq() else {
+                continue;
+            };
+            let is_better = best.is_none_or(|(_, best_freq)| freq < best_freq);
+            if is_better {
                 best = Some((idx, freq));
             }
         }

src/ds/ghost_list.rs

@@ -80,10 +80,10 @@ where
             return;
         }
 
-        if self.list.len() >= self.capacity
-            && let Some(old_key) = self.list.pop_back()
-        {
-            self.index.remove(&old_key);
+        if self.list.len() >= self.capacity {
+            if let Some(old_key) = self.list.pop_back() {
+                self.index.remove(&old_key);
+            }
         }
 
         let id = self.list.push_front(key.clone());

src/policy/heap_lfu.rs

@@ -366,12 +366,12 @@ where
     fn pop_lfu_internal(&mut self) -> Option<(K, u64)> {
         let mut stale_pops = 0usize;
         while let Some(Reverse((heap_freq, key))) = self.freq_heap.peek() {
-            if let Some(&current_freq) = self.frequencies.get(key)
-                && *heap_freq == current_freq
-            {
-                // This is a valid (non-stale) entry
-                let Reverse((freq, key)) = self.freq_heap.pop().unwrap();
-                return Some((key, freq));
+            if let Some(&current_freq) = self.frequencies.get(key) {
+                if *heap_freq == current_freq {
+                    // This is a valid (non-stale) entry
+                    let Reverse((freq, key)) = self.freq_heap.pop().unwrap();
+                    return Some((key, freq));
+                }
             }
 
             // This entry is stale (key doesn't exist or frequency changed)