Cleaned up some control flow and optimized some parts. (#1241)

Larmbs · IvanIsCoding · web-flow · commit 553bff1823a3 · 2024-07-03T23:18:17.000-04:00
* Tweaks to mostly control flow, as well as some grammar corrections.

* Formated parts

---------

Co-authored-by: Ivan Carvalho &lt;8753214+IvanIsCoding@users.noreply.github.com&gt;
diff --git a/rustworkx-core/src/bipartite_coloring.rs b/rustworkx-core/src/bipartite_coloring.rs
@@ -340,18 +340,18 @@ fn rbmg_edge_color(g0: &RegularBipartiteMultiGraph) -> Vec<Matching> {
     let mut g: RegularBipartiteMultiGraph = RegularBipartiteMultiGraph::clone(g0);
     let mut coloring: Vec<Matching> = Vec::with_capacity(g.degree);
 
-    if g.degree == 0 {
-        return coloring;
-    }
-
-    if g.degree == 1 {
-        let mut matching: Matching = Vec::with_capacity(g.l_nodes.len());
-        for edge in g.graph.edge_references() {
-            matching.push((edge.source(), edge.target()));
+    match g.degree {
+        0 => return coloring,
+        1 => {
+            let mut matching: Matching = Vec::with_capacity(g.l_nodes.len());
+            for edge in g.graph.edge_references() {
+                matching.push((edge.source(), edge.target()));
+            }
+            coloring.push(matching);
+            return coloring;
         }
-        coloring.push(matching);
-        return coloring;
-    }
+        _ => (),
+    };
 
     let mut odd_degree_matching: Option<Matching> = None;
 
diff --git a/rustworkx-core/src/connectivity/biconnected.rs b/rustworkx-core/src/connectivity/biconnected.rs
@@ -140,7 +140,7 @@ where
                 }
             }
         }
-        _ => {}
+        _ => (),
     });
 
     if let Some(x) = components {
diff --git a/rustworkx-core/src/dag_algo.rs b/rustworkx-core/src/dag_algo.rs
@@ -595,16 +595,17 @@ where
             // Remove null edges from color_fn
             let colors = colors.into_iter().flatten().collect::<Vec<usize>>();
 
-            if colors.len() <= 2 && is_match {
-                if colors.len() == 1 {
+            match (colors.len(), is_match) {
+                (1, true) => {
                     let c0 = colors[0];
                     ensure_vector_has_index!(pending_list, block_id, c0);
                     if let Some(c0_block_id) = block_id[c0] {
                         block_list[c0_block_id].push(node);
                     } else {
                         pending_list[c0].push(node);
                     }
-                } else if colors.len() == 2 {
+                }
+                (2, true) => {
                     let c0 = colors[0];
                     let c1 = colors[1];
                     ensure_vector_has_index!(pending_list, block_id, c0);
@@ -619,7 +620,7 @@ where
                         let mut new_block: Vec<G::NodeId> =
                             Vec::with_capacity(pending_list[c0].len() + pending_list[c1].len() + 1);
 
-                        // Clears pending lits and add to new block
+                        // Clears pending list and add to new block
                         new_block.append(&mut pending_list[c0]);
                         new_block.append(&mut pending_list[c1]);
 
@@ -631,14 +632,15 @@ where
                         block_list.push(new_block);
                     }
                 }
-            } else {
-                for color in colors {
-                    ensure_vector_has_index!(pending_list, block_id, color);
-                    if let Some(color_block_id) = block_id[color] {
-                        block_list[color_block_id].append(&mut pending_list[color]);
+                _ => {
+                    for color in colors {
+                        ensure_vector_has_index!(pending_list, block_id, color);
+                        if let Some(color_block_id) = block_id[color] {
+                            block_list[color_block_id].append(&mut pending_list[color]);
+                        }
+                        block_id[color] = None;
+                        pending_list[color].clear();
                     }
-                    block_id[color] = None;
-                    pending_list[color].clear();
                 }
             }
         }
diff --git a/rustworkx-core/src/generators/barbell_graph.rs b/rustworkx-core/src/generators/barbell_graph.rs
@@ -151,10 +151,9 @@ where
             default_edge_weight(),
         );
         for (node_a, node_b) in pairwise(path_nodes) {
-            match node_a {
-                Some(node_a) => graph.add_edge(node_a, node_b, default_edge_weight()),
-                None => continue,
-            };
+            if let Some(node_a) = node_a {
+                graph.add_edge(node_a, node_b, default_edge_weight());
+            }
         }
     }
 
diff --git a/rustworkx-core/src/generators/heavy_hex_graph.rs b/rustworkx-core/src/generators/heavy_hex_graph.rs
@@ -170,7 +170,7 @@ where
                     default_edge_weight(),
                 );
             }
-        } else if i % 2 == 1 {
+        } else {
             graph.add_edge(
                 nodes_data[i * d + (d - 1)],
                 syndrome_chunk[syndrome_chunk.len() - 1],
@@ -225,7 +225,7 @@ where
                     }
                 }
             }
-        } else if i % 2 == 1 {
+        } else {
             for (j, syndrome) in syndrome_chunk.iter().enumerate() {
                 if j != syndrome_chunk.len() - 1 {
                     graph.add_edge(
diff --git a/rustworkx-core/src/generators/heavy_square_graph.rs b/rustworkx-core/src/generators/heavy_square_graph.rs
@@ -171,7 +171,7 @@ where
                     default_edge_weight(),
                 );
             }
-        } else if i % 2 == 1 {
+        } else {
             graph.add_edge(nodes_data[i * d], syndrome_chunk[0], default_edge_weight());
             graph.add_edge(
                 nodes_data[(i + 1) * d],
@@ -218,7 +218,7 @@ where
                     }
                 }
             }
-        } else if i % 2 == 1 {
+        } else {
             for (j, syndrome) in syndrome_chunk.iter().enumerate() {
                 if j != 0 {
                     graph.add_edge(
diff --git a/rustworkx-core/src/generators/utils.rs b/rustworkx-core/src/generators/utils.rs
@@ -12,8 +12,8 @@
 
 #[inline]
 pub fn get_num_nodes<T>(num_nodes: &Option<usize>, weights: &Option<Vec<T>>) -> usize {
-    if weights.is_some() {
-        weights.as_ref().unwrap().len()
+    if let Some(v) = weights {
+        v.len()
     } else {
         num_nodes.unwrap()
     }
diff --git a/rustworkx-core/src/graph_ext/contraction.rs b/rustworkx-core/src/graph_ext/contraction.rs
@@ -556,11 +556,7 @@ where
             .flat_map(|i| graph.edges_directed(*i, Direction::Incoming))
             .filter_map(|edge| {
                 let pred = edge.source();
-                if !nodes.contains(&pred) {
-                    Some((pred, edge.weight().clone()))
-                } else {
-                    None
-                }
+                (!nodes.contains(&pred)).then_some((pred, edge.weight().clone()))
             })
             .collect();
 
@@ -579,11 +575,7 @@ where
             .flat_map(|&i| graph.edges_directed(i, Direction::Outgoing))
             .filter_map(|edge| {
                 let succ = edge.target();
-                if !nodes.contains(&succ) {
-                    Some((succ, edge.weight().clone()))
-                } else {
-                    None
-                }
+                (!nodes.contains(&succ)).then_some((succ, edge.weight().clone()))
             })
             .collect();
 
diff --git a/rustworkx-core/src/min_scored.rs b/rustworkx-core/src/min_scored.rs
@@ -35,7 +35,7 @@ pub struct MinScored<K, T>(pub K, pub T);
 impl<K: PartialOrd, T> PartialEq for MinScored<K, T> {
     #[inline]
     fn eq(&self, other: &MinScored<K, T>) -> bool {
-        self.cmp(other) == Ordering::Equal
+        self.cmp(other).is_eq()
     }
 }
 
diff --git a/rustworkx-core/src/planar/lr_planar.rs b/rustworkx-core/src/planar/lr_planar.rs
@@ -55,11 +55,7 @@ where
         .edges(a)
         .filter_map(|edge| {
             let e = (edge.source(), edge.target());
-            if filter(&e) {
-                Some(e)
-            } else {
-                None
-            }
+            filter(&e).then_some(e)
         })
         .collect::<Vec<_>>();
     edges.sort_by_key(compare);
@@ -335,7 +331,7 @@ where
                     }
                 }
             }
-            _ => {}
+            _ => (),
         }
     }
 
diff --git a/rustworkx-core/src/steiner_tree.rs b/rustworkx-core/src/steiner_tree.rs
@@ -61,6 +61,7 @@ where
             })
             .collect());
     }
+
     let mut edge_weights: Vec<Option<f64>> = vec![None; graph.edge_bound()];
     for edge in graph.edge_references() {
         let index = EdgeIndexable::to_index(&graph, edge.id());
diff --git a/rustworkx-core/src/token_swapper.rs b/rustworkx-core/src/token_swapper.rs
@@ -196,7 +196,7 @@ where
         // Adds an edge to digraph if distance from the token to a neighbor is
         // less than distance from token to node. sub_digraph is same except
         // for self-edges.
-        if !(tokens.contains_key(&node)) {
+        if !tokens.contains_key(&node) {
             return Ok(());
         }
         if tokens[&node] == node {

Original file line number	Diff line number	Diff line change
`@@ -140,7 +140,7 @@ where`
`140`	`140`	`}`
`141`	`141`	`}`
`142`	`142`	`}`
`143`		`- _ => {}`
	`143`	`+ _ => (),`
`144`	`144`	`});`
`145`	`145`
`146`	`146`	`if let Some(x) = components {`
Original file line number	Diff line number	Diff line change
`@@ -151,10 +151,9 @@ where`
`151`	`151`	`default_edge_weight(),`
`152`	`152`	`);`
`153`	`153`	`for (node_a, node_b) in pairwise(path_nodes) {`
`154`		`- match node_a {`
`155`		`- Some(node_a) => graph.add_edge(node_a, node_b, default_edge_weight()),`
`156`		`- None => continue,`
`157`		`- };`
	`154`	`+ if let Some(node_a) = node_a {`
	`155`	`+ graph.add_edge(node_a, node_b, default_edge_weight());`
	`156`	`+ }`
`158`	`157`	`}`
`159`	`158`	`}`
`160`	`159`
Original file line number	Diff line number	Diff line change
`@@ -170,7 +170,7 @@ where`
`170`	`170`	`default_edge_weight(),`
`171`	`171`	`);`
`172`	`172`	`}`
`173`		`- } else if i % 2 == 1 {`
	`173`	`+ } else {`
`174`	`174`	`graph.add_edge(`
`175`	`175`	`nodes_data[i * d + (d - 1)],`
`176`	`176`	`syndrome_chunk[syndrome_chunk.len() - 1],`
`@@ -225,7 +225,7 @@ where`
`225`	`225`	`}`
`226`	`226`	`}`
`227`	`227`	`}`
`228`		`- } else if i % 2 == 1 {`
	`228`	`+ } else {`
`229`	`229`	`for (j, syndrome) in syndrome_chunk.iter().enumerate() {`
`230`	`230`	`if j != syndrome_chunk.len() - 1 {`
`231`	`231`	`graph.add_edge(`
Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ where`
`171`	`171`	`default_edge_weight(),`
`172`	`172`	`);`
`173`	`173`	`}`
`174`		`- } else if i % 2 == 1 {`
	`174`	`+ } else {`
`175`	`175`	`graph.add_edge(nodes_data[i * d], syndrome_chunk[0], default_edge_weight());`
`176`	`176`	`graph.add_edge(`
`177`	`177`	`nodes_data[(i + 1) * d],`
`@@ -218,7 +218,7 @@ where`
`218`	`218`	`}`
`219`	`219`	`}`
`220`	`220`	`}`
`221`		`- } else if i % 2 == 1 {`
	`221`	`+ } else {`
`222`	`222`	`for (j, syndrome) in syndrome_chunk.iter().enumerate() {`
`223`	`223`	`if j != 0 {`
`224`	`224`	`graph.add_edge(`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ pub struct MinScored<K, T>(pub K, pub T);`
`35`	`35`	`impl<K: PartialOrd, T> PartialEq for MinScored<K, T> {`
`36`	`36`	`#[inline]`
`37`	`37`	`fn eq(&self, other: &MinScored<K, T>) -> bool {`
`38`		`- self.cmp(other) == Ordering::Equal`
	`38`	`+ self.cmp(other).is_eq()`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
Original file line number	Diff line number	Diff line change
`@@ -55,11 +55,7 @@ where`
`55`	`55`	`.edges(a)`
`56`	`56`	`.filter_map(\|edge\| {`
`57`	`57`	`let e = (edge.source(), edge.target());`
`58`		`- if filter(&e) {`
`59`		`- Some(e)`
`60`		`- } else {`
`61`		`- None`
`62`		`- }`
	`58`	`+ filter(&e).then_some(e)`
`63`	`59`	`})`
`64`	`60`	`.collect::<Vec<_>>();`
`65`	`61`	`edges.sort_by_key(compare);`
`@@ -335,7 +331,7 @@ where`
`335`	`331`	`}`
`336`	`332`	`}`
`337`	`333`	`}`
`338`		`- _ => {}`
	`334`	`+ _ => (),`
`339`	`335`	`}`
`340`	`336`	`}`
`341`	`337`