Merge pull request #23 from orxfun/upgrade-clippy

upgrade clippy

Author: orxfun

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "orx-priority-queue"
-version = "1.4.0"
+version = "1.4.1"
 edition = "2021"
 authors = ["orxfun <[email protected]>"]
 description = "Priority queue traits and high performance d-ary heap implementations."
@@ -15,15 +15,15 @@ std = []
 impl_priority_queue = ["priority-queue"]
 
 [dependencies]
-priority-queue = { version = "2.0", optional = true }
+priority-queue = { version = "2.1", optional = true }
 
 
 [[bench]]
 name = "basic_queue"
 harness = false
 
 [dev-dependencies]
-itertools = "0.11"
+itertools = "0.13"
 rand = "0.8"
 rand_chacha = "0.3"
 criterion = { version = "0.5", features = ["html_reports"] }

src/dary/daryheap_index.rs

@@ -26,10 +26,10 @@ pub type QuaternaryHeapOfIndices<N, K> = DaryHeapOfIndices<N, K, 4>;
 /// due to the following:
 /// * using a fixed size array could be considered as a fast `HashMap`.
 /// * we often reuse such heaps many times to solve many problems on the same network,
-/// compensating for the allocation of the positions array once.
+///   compensating for the allocation of the positions array once.
 /// * further, compared to a basic priority queue (or to `std::collections::BinaryHeap`),
-/// it reduces the space complexity of the Dijkstra's
-/// algorithm from *O(N^2)* to *O(N)* by enabling the `decrease_key` operation.
+///   it reduces the space complexity of the Dijkstra's
+///   algorithm from *O(N^2)* to *O(N)* by enabling the `decrease_key` operation.
 ///
 /// However, for situations where
 /// * the number of nodes entering the queue is very sparse compared to the size of the set of nodes, or
@@ -227,8 +227,18 @@ where
     N: HasIndex,
     K: PartialOrd + Clone,
 {
-    type NodeKey<'a> = &'a (N, K) where Self: 'a, N: 'a, K: 'a;
-    type Iter<'a> = core::slice::Iter<'a, (N, K)> where Self: 'a, N: 'a, K: 'a;
+    type NodeKey<'a>
+        = &'a (N, K)
+    where
+        Self: 'a,
+        N: 'a,
+        K: 'a;
+    type Iter<'a>
+        = core::slice::Iter<'a, (N, K)>
+    where
+        Self: 'a,
+        N: 'a,
+        K: 'a;
 
     #[inline(always)]
     fn len(&self) -> usize {

src/lib.rs

@@ -322,7 +322,9 @@
     clippy::missing_panics_doc,
     clippy::todo
 )]
-#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(any(test, feature = "std"))]
+extern crate std;
 
 extern crate alloc;
 

src/priority_queue_deckey.rs

@@ -64,11 +64,12 @@ where
     /// # Panics
     /// This method panics:
     /// * if the `node` is not in the queue; or
-    ///     * see [`PriorityQueueDecKey::try_decrease_key_or_push`] for a variant which pushes the
-    /// `(node, new_key)` pair if the `node` is absent, rather than panicking;
-    /// * if `decreased_key` is strictly larger than key of the `node` in the queue,
-    ///     * see [`PriorityQueueDecKey::try_decrease_key`] for a variant which does nothing
-    /// if the new key is strictly larger than key of the `node` in the queue, rather than panicking.
+    ///   (see also [`try_decrease_key_or_push`])
+    /// * if `decreased_key` is strictly larger than key of the `node` in the queue
+    ///   (see also [`try_decrease_key`]).
+    ///
+    /// [`try_decrease_key_or_push`]: PriorityQueueDecKey::try_decrease_key_or_push
+    /// [`try_decrease_key`]: PriorityQueueDecKey::try_decrease_key
     ///
     /// # Examples
     ///
@@ -97,9 +98,9 @@ where
     ///
     /// # Panics
     /// This method panics if:
-    /// * the `node` is not in the queue,
-    ///     * see [`PriorityQueueDecKey::update_key_or_push`] for a variant which pushes the
-    /// `(node, new_key)` pair if the `node` is absent, rather than panicking.
+    /// * the `node` is not in the queue (see also [`update_key_or_push`]).
+    ///
+    /// [`update_key_or_push`]: PriorityQueueDecKey::update_key_or_push
     ///
     /// # Examples
     ///
@@ -170,7 +171,7 @@ where
 
     /// If the `node` is present in the queue:
     /// * decreases key of the `node` to the given `decreased_key`; `decreased_key` is expected to be less than or equal
-    /// to the prior key;
+    ///   to the prior key;
     ///
     /// otherwise:
     /// * pushes the new (node, key) pair to the queue.
@@ -182,11 +183,11 @@ where
     ///
     /// # Panics
     /// This method panics
-    /// * if the `node` is in the queue; however, its current key is strictly less than the provided `key`;
-    ///     * see [`PriorityQueueDecKey::update_key_or_push`] for a variant which increases the key
-    /// if the new key is strictly larger than key of the `node` in the queue, rather than panicking; or
-    ///     * see [`PriorityQueueDecKey::try_decrease_key_or_push`] for a variant which does nothing
-    /// if the new key is strictly larger than key of the `node` in the queue, rather than panicking.
+    /// * if the `node` is in the queue; however, its current key is strictly less than the provided `key`
+    ///   (see also [`update_key_or_push`] and [`try_decrease_key_or_push`]).
+    ///
+    /// [`update_key_or_push`]: PriorityQueueDecKey::update_key_or_push
+    /// [`try_decrease_key_or_push`]: PriorityQueueDecKey::try_decrease_key_or_push
     ///
     /// # Examples
     ///