Fix all warnings

factorio-graph/src/priority_queue/bucket_queue.rs

@@ -1,7 +1,6 @@
+use super::PriorityQueueByKey;
 use std::collections::{HashMap, VecDeque};
 
-use super::{PriorityQueue, PriorityQueueByKey};
-
 pub struct BucketQueue<Item> {
     min: i64,
     data: VecDeque<Vec<(usize, Item)>>,

factorio-graph/src/set_cover.rs

@@ -6,20 +6,20 @@ use crate::{graph::Graph, priority_queue::PriorityQueue};
 
 #[derive(Debug, Clone, Copy)]
 pub struct SetUncovered {
-    setIndex: usize,
-    uncoveredElements: usize,
+    set_index: usize,
+    uncovered_elements: usize,
 }
 
 impl PartialEq for SetUncovered {
     fn eq(&self, other: &Self) -> bool {
-        self.uncoveredElements.eq(&other.uncoveredElements)
+        self.uncovered_elements.eq(&other.uncovered_elements)
     }
 }
 
 impl PartialOrd for SetUncovered {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        self.uncoveredElements
-            .partial_cmp(&other.uncoveredElements)
+        self.uncovered_elements
+            .partial_cmp(&other.uncovered_elements)
             .map(|o| o.reverse())
     }
 }
@@ -72,8 +72,8 @@ where
         .enumerate()
         .map(|(i, s)| {
             Some(p.insert(SetUncovered {
-                setIndex: i,
-                uncoveredElements: s.len(),
+                set_index: i,
+                uncovered_elements: s.len(),
             }))
         })
         .collect::<Vec<_>>();
@@ -82,8 +82,8 @@ where
 
     while covered_count < universe {
         let SetUncovered {
-            setIndex: i,
-            uncoveredElements: _,
+            set_index: i,
+            uncovered_elements: _,
         } = p.pop_min().unwrap();
 
         r.push(i);
@@ -102,7 +102,7 @@ where
             }
 
             // dbg!(decrease, i, s.deref());
-            p.increase_key(h, |e| e.uncoveredElements -= decrease);
+            p.increase_key(h, |e| e.uncovered_elements -= decrease);
         }
 
         for &e in sets[i].deref() {
@@ -161,15 +161,15 @@ where
     }
     for e in graph.edge_iter(&i) {
         handles[e] = HandleOption::Seen(p.insert(SetUncovered {
-            setIndex: e,
-            uncoveredElements: sets[e].iter().filter(|&&v| !covered[v]).count(),
+            set_index: e,
+            uncovered_elements: sets[e].iter().filter(|&&v| !covered[v]).count(),
         }));
     }
 
     while covered_count < universe {
         let SetUncovered {
-            setIndex: i,
-            uncoveredElements: _,
+            set_index: i,
+            uncovered_elements: _,
         } = p.pop_min().unwrap();
 
         r.push(i);
@@ -192,7 +192,7 @@ where
             }
 
             // dbg!(decrease, i, s.deref());
-            p.increase_key(h, |e| e.uncoveredElements -= decrease);
+            p.increase_key(h, |e| e.uncovered_elements -= decrease);
         }
 
         for &e in sets[i].deref() {
@@ -204,8 +204,8 @@ where
         for e in graph.edge_iter(&i) {
             if matches!(handles[e], HandleOption::Unknown) {
                 handles[e] = HandleOption::Seen(p.insert(SetUncovered {
-                    setIndex: e,
-                    uncoveredElements: sets[e].iter().filter(|&&v| !covered[v]).count(),
+                    set_index: e,
+                    uncovered_elements: sets[e].iter().filter(|&&v| !covered[v]).count(),
                 }));
             }
         }

factorio-graph/src/wheighted_graph/shortest_path.rs

@@ -1,10 +1,7 @@
-use std::{collections::HashMap, fmt::Debug, hash::Hash, hash::Hasher};
-
-use tracing::{field::Empty, trace_span};
-
-use crate::priority_queue::{PriorityQueue, PriorityQueueByKey};
-
 use super::WheightedGraph;
+use crate::priority_queue::PriorityQueueByKey;
+use std::{collections::HashMap, fmt::Debug, hash::Hash, hash::Hasher};
+use tracing::{field::Empty, trace_span};
 
 #[derive(Debug, Clone, Copy)]
 pub struct QueueObject<N> {

factorio-graph/src/wheighted_graph/steiner_tree.rs

@@ -1,11 +1,9 @@
-use tracing::trace_span;
-
-use crate::priority_queue::{PriorityQueue, PriorityQueueByKey};
-use std::hash::Hash;
-use std::{collections::HashSet, fmt::Debug};
-
 use super::shortest_path::dijkstra;
 use super::{WheightedGraph, shortest_path::QueueObject};
+use crate::priority_queue::PriorityQueueByKey;
+use std::collections::HashSet;
+use std::hash::Hash;
+use tracing::trace_span;
 
 struct MultistartWrapper<'a, 'b, G>
 where