diff --git a/src/iter/traverser.rs b/src/iter/traverser.rs
index 965269d..bfb9cac 100644
--- a/src/iter/traverser.rs
+++ b/src/iter/traverser.rs
@@ -128,8 +128,9 @@ impl<'g, K, V> Iterator for NodeIter<'g, K, V> {
                     BinEntry::TreeNode(ref tree_node) => {
                         e = Some(&tree_node.node);
                     }
-                    BinEntry::Moved => unreachable!("Nodes can only point to Nodes or TreeNodes"),
-                    BinEntry::Tree(_) => unreachable!("Nodes can only point to Nodes or TreeNodes"),
+                    BinEntry::Moved | BinEntry::Tree(_) => {
+                        unreachable!("Nodes can only point to Nodes or TreeNodes")
+                    }
                 }
             }
         }
diff --git a/src/map.rs b/src/map.rs
index 6a652cf..6b1ad8d 100644
--- a/src/map.rs
+++ b/src/map.rs
@@ -1720,11 +1720,10 @@ where
                     Err(changed) => {
                         assert!(!changed.current.is_null());
                         bin = changed.current;
-                        if let BinEntry::Node(node) = unsafe { changed.new.into_box() }.value {
-                            key = node.key;
-                        } else {
+                        let BinEntry::Node(node) = unsafe { changed.new.into_box() }.value else {
                             unreachable!("we declared node and it is a BinEntry::Node");
-                        }
+                        };
+                        key = node.key;
                     }
                 }
             }
diff --git a/src/node.rs b/src/node.rs
index f8ad720..f24e206 100644
--- a/src/node.rs
+++ b/src/node.rs
@@ -949,11 +949,10 @@ impl<K, V> TreeBin<K, V> {
                 Box::from_raw(ptr).value
             };
 
-            if let BinEntry::Tree(mut tree_bin) = bin {
-                tree_bin.drop_fields(false);
-            } else {
+            let BinEntry::Tree(mut tree_bin) = bin else {
                 unreachable!("bin is a tree bin");
-            }
+            };
+            tree_bin.drop_fields(false);
         });
     }
 
@@ -988,16 +987,15 @@ impl<K, V> TreeBin<K, V> {
     ) {
         let mut p = from;
         while !p.is_null() {
-            if let BinEntry::TreeNode(tree_node) = p.into_box().value {
-                // if specified, drop the value in this node
-                if drop_values {
-                    let _ = tree_node.node.value.into_box();
-                }
-                // then we move to the next node
-                p = tree_node.node.next.load(Ordering::SeqCst, guard);
-            } else {
+            let BinEntry::TreeNode(tree_node) = p.into_box().value else {
                 unreachable!("Trees can only ever contain TreeNodes");
             };
+            // if specified, drop the value in this node
+            if drop_values {
+                let _ = tree_node.node.value.into_box();
+            }
+            // then we move to the next node
+            p = tree_node.node.next.load(Ordering::SeqCst, guard);
         }
     }
 }
diff --git a/src/raw/mod.rs b/src/raw/mod.rs
index 7427ad2..90f209d 100644
--- a/src/raw/mod.rs
+++ b/src/raw/mod.rs
@@ -117,9 +117,7 @@ impl<K, V> Table<K, V> {
             BinEntry::Node(_) => {
                 let mut node = bin;
                 loop {
-                    let n = if let BinEntry::Node(ref n) = **node {
-                        n
-                    } else {
+                    let BinEntry::Node(ref n) = **node else {
                         unreachable!("BinEntry::Node only points to BinEntry::Node");
                     };
 
@@ -209,9 +207,7 @@ impl<K, V> Table<K, V> {
                         // we replaced the bin with a NULL, so there's no future way to access it
                         // either; we own all the nodes in the list.
 
-                        let node = if let BinEntry::Node(node) = p.value {
-                            node
-                        } else {
+                        let BinEntry::Node(node) = p.value else {
                             unreachable!();
                         };
 
@@ -228,10 +224,8 @@ impl<K, V> Table<K, V> {
                 BinEntry::Tree(_) => {
                     // safety: same as for BinEntry::Node
                     let p = unsafe { bin.into_box() };
-                    let bin = if let BinEntry::Tree(bin) = p.value {
-                        bin
-                    } else {
-                        unreachable!();
+                    let BinEntry::Tree(bin) = p.value else {
+                        unreachable!()
                     };
                     // TreeBin::drop will take care of freeing the contained TreeNodes and their values
                     drop(bin);