clippy errors fixed

Author: orxfun

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "orx-linked-list"
-version = "3.2.0"
+version = "3.3.0"
 edition = "2021"
 authors = ["orxfun <[email protected]>"]
 description = "A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations."
@@ -14,10 +14,10 @@ orx-pseudo-default = { version = "1.4", default-features = false }
 orx-pinned-vec = "3.11"
 orx-split-vec = "3.11"
 orx-fixed-vec = "3.11"
-orx-selfref-col = "2.2"
+orx-selfref-col = "2.3"
 
 [dev-dependencies]
-clap = { version = "4.5.17", features = ["derive"] }
+clap = { version = "4.5.27", features = ["derive"] }
 criterion = "0.5"
 rand = "0.8.5"
 rand_chacha = "0.3.1"

src/list/ends_traits/doubly_ends.rs

@@ -39,7 +39,7 @@ where
     {
         self.ends()
             .get(FRONT_IDX)
-            .map(|p| unsafe { self.col().data_unchecked(&p) })
+            .map(|p| unsafe { self.col().data_unchecked(p) })
     }
 
     /// ***O(1)*** Returns a reference to the back of the list.
@@ -72,7 +72,7 @@ where
     {
         self.ends()
             .get(BACK_IDX)
-            .map(|p| unsafe { self.col().data_unchecked(&p) })
+            .map(|p| unsafe { self.col().data_unchecked(p) })
     }
 
     // idx
@@ -529,7 +529,7 @@ where
     fn next_idx_of(&self, idx: &DoublyIdx<T>) -> Option<DoublyIdx<T>> {
         let ptr = self.col().try_get_ptr(idx).expect(IDX_ERR);
         let next_ptr = self.col().node(&ptr).next().get();
-        next_ptr.map(|p| DoublyIdx::new(self.col().memory_state(), &p))
+        next_ptr.map(|p| DoublyIdx::new(self.col().memory_state(), p))
     }
 
     /// ***O(1)*** Returns the element succeeding the one with the given `idx`.
@@ -596,7 +596,7 @@ where
     fn prev_idx_of(&self, idx: &DoublyIdx<T>) -> Option<DoublyIdx<T>> {
         let ptr = self.col().try_get_ptr(idx).expect(IDX_ERR);
         let prev_ptr = self.col().node(&ptr).prev().get();
-        prev_ptr.map(|p| DoublyIdx::new(self.col().memory_state(), &p))
+        prev_ptr.map(|p| DoublyIdx::new(self.col().memory_state(), p))
     }
 
     /// ***O(1)*** Returns the element preceding the one with the given `idx`.

src/list/ends_traits/doubly_ends_mut.rs

@@ -699,7 +699,7 @@ where
     /// ```
     fn move_to_front(&mut self, idx: &DoublyIdx<T>) {
         let ptr = self.ends().get(FRONT_IDX).expect(OOB);
-        let idx_target = NodeIdx::new(self.col().memory_state(), &ptr);
+        let idx_target = NodeIdx::new(self.col().memory_state(), ptr);
         self.move_prev_to(idx, &idx_target);
     }
 
@@ -731,7 +731,7 @@ where
     /// ```
     fn move_to_back(&mut self, idx: &DoublyIdx<T>) {
         let ptr = self.ends().get(BACK_IDX).expect(OOB);
-        let idx_target = NodeIdx::new(self.col().memory_state(), &ptr);
+        let idx_target = NodeIdx::new(self.col().memory_state(), ptr);
         self.move_next_to(idx, &idx_target);
     }
 

src/list/ends_traits/singly_ends.rs

@@ -35,7 +35,7 @@ where
     {
         self.ends()
             .get()
-            .map(|p| unsafe { self.col().data_unchecked(&p) })
+            .map(|p| unsafe { self.col().data_unchecked(p) })
     }
 
     // idx
@@ -492,7 +492,7 @@ where
     fn next_idx_of(&self, idx: &SinglyIdx<T>) -> Option<SinglyIdx<T>> {
         let ptr = self.col().try_get_ptr(idx).expect(IDX_ERR);
         let next_ptr = self.col().node(&ptr).next().get();
-        next_ptr.map(|p| SinglyIdx::new(self.col().memory_state(), &p))
+        next_ptr.map(|p| SinglyIdx::new(self.col().memory_state(), p))
     }
 
     /// ***O(1)*** Returns the element succeeding the one with the given `idx`.

src/memory/doubly_reclaimer.rs

@@ -66,11 +66,11 @@ fn swap<P, T>(
     }
 
     if let Some(prev) = (unsafe { &*occupied }).prev().get() {
-        col.node_mut(&prev).next_mut().set(node_ptr(vacant));
+        col.node_mut(prev).next_mut().set(node_ptr(vacant));
     }
 
     if let Some(next) = (unsafe { &*occupied }).next().get() {
-        col.node_mut(&next).prev_mut().set(node_ptr(vacant));
+        col.node_mut(next).prev_mut().set(node_ptr(vacant));
     }
 
     core::mem::swap(unsafe { &mut *(vacant as *mut Node<Doubly<T>>) }, unsafe {

src/tests/doubly.rs

@@ -39,12 +39,12 @@ where
                 assert_eq!(self.0.ends().get(BACK_IDX), self.0.ends().get(FRONT_IDX));
 
                 let front_ptr = self.0.ends().get(FRONT_IDX).unwrap();
-                assert!(self.next(&front_ptr).is_none());
-                assert!(self.prev(&front_ptr).is_none());
+                assert!(self.next(front_ptr).is_none());
+                assert!(self.prev(front_ptr).is_none());
 
                 let back_ptr = self.0.ends().get(BACK_IDX).unwrap();
-                assert!(self.next(&back_ptr).is_none());
-                assert!(self.prev(&back_ptr).is_none());
+                assert!(self.next(back_ptr).is_none());
+                assert!(self.prev(back_ptr).is_none());
             }
             _ => {
                 assert!(self.front().is_some());
@@ -111,14 +111,14 @@ where
 
     fn next(&self, ptr: &NodePtr<Doubly<T>>) -> Option<PtrAndNode<T>> {
         self.0.node(ptr).next().get().map(|p| {
-            let next_node = self.0.node(&p);
+            let next_node = self.0.node(p);
             (p.clone(), next_node)
         })
     }
 
     fn prev(&self, ptr: &NodePtr<Doubly<T>>) -> Option<PtrAndNode<T>> {
         self.0.node(ptr).prev().get().map(|p| {
-            let prev_node = self.0.node(&p);
+            let prev_node = self.0.node(p);
             (p.clone(), prev_node)
         })
     }

src/tests/singly.rs

@@ -33,7 +33,7 @@ where
                 assert!(self.front().is_some());
 
                 let front_ptr = self.0.ends().get().unwrap();
-                assert!(self.next(&front_ptr).is_none());
+                assert!(self.next(front_ptr).is_none());
             }
             _ => {
                 assert!(self.front().is_some());