Fix clippy warnings for Rust 1.86 (#1414)

* First batch of fixes

* Second batch of fixes

* Third batch of fixes

* Fourth batch of fixes

* Fifth batch of fixes

* Last batch of fixes

Author: IvanIsCoding

rustworkx-core/src/bipartite_coloring.rs

@@ -411,7 +411,7 @@ fn rbmg_edge_color(g0: &RegularBipartiteMultiGraph) -> Vec<Matching> {
 /// Arguments:
 ///
 /// * `graph` - The graph object to run the algorithm on. The graph is
-///     assumed to be bipartite.
+///   assumed to be bipartite.
 /// * `l_nodes` - The vector containing the "left" nodes of the graph.
 /// * `r_nodes` - The vector containing the "right" nodes of the graph.
 ///

rustworkx-core/src/centrality.rs

@@ -39,14 +39,14 @@ use rayon_cond::CondIterator;
 ///
 /// * `graph` - The graph object to run the algorithm on
 /// * `include_endpoints` - Whether to include the endpoints of paths in the path
-///     lengths used to compute the betweenness
+///   lengths used to compute the betweenness
 /// * `normalized` - Whether to normalize the betweenness scores by the number
-///     of distinct paths between all pairs of nodes
+///   of distinct paths between all pairs of nodes
 /// * `parallel_threshold` - The number of nodes to calculate the betweenness
-///     centrality in parallel at, if the number of nodes in `graph` is less
-///     than this value it will run in a single thread. A good default to use
-///     here if you're not sure is `50` as that was found to be roughly the
-///     number of nodes where parallelism improves performance
+///   centrality in parallel at, if the number of nodes in `graph` is less
+///   than this value it will run in a single thread. A good default to use
+///   here if you're not sure is `50` as that was found to be roughly the
+///   number of nodes where parallelism improves performance
 ///
 /// # Example
 /// ```rust
@@ -147,12 +147,12 @@ where
 ///
 /// * `graph` - The graph object to run the algorithm on
 /// * `normalized` - Whether to normalize the betweenness scores by the number
-///     of distinct paths between all pairs of nodes
+///   of distinct paths between all pairs of nodes
 /// * `parallel_threshold` - The number of nodes to calculate the betweenness
-///     centrality in parallel at, if the number of nodes in `graph` is less
-///     than this value it will run in a single thread. A good default to use
-///     here if you're not sure is `50` as that was found to be roughly the
-///     number of nodes where parallelism improves performance
+///   centrality in parallel at, if the number of nodes in `graph` is less
+///   than this value it will run in a single thread. A good default to use
+///   here if you're not sure is `50` as that was found to be roughly the
+///   number of nodes where parallelism improves performance
 ///
 /// # Example
 /// ```rust
@@ -666,12 +666,12 @@ mod test_edge_betweenness_centrality {
 ///
 /// * `graph` - The graph object to run the algorithm on
 /// * `weight_fn` - An input callable that will be passed the `EdgeRef` for
-///     an edge in the graph and is expected to return a `Result<f64>` of
-///     the weight of that edge.
+///   an edge in the graph and is expected to return a `Result<f64>` of
+///   the weight of that edge.
 /// * `max_iter` - The maximum number of iterations in the power method. If
-///     set to `None` a default value of 100 is used.
+///   set to `None` a default value of 100 is used.
 /// * `tol` - The error tolerance used when checking for convergence in the
-///     power method. If set to `None` a default value of 1e-6 is used.
+///   power method. If set to `None` a default value of 1e-6 is used.
 ///
 /// # Example
 /// ```rust
@@ -752,16 +752,16 @@ where
 ///
 /// * `graph` - The graph object to run the algorithm on
 /// * `weight_fn` - An input callable that will be passed the `EdgeRef` for
-///     an edge in the graph and is expected to return a `Result<f64>` of
-///     the weight of that edge.
+///   an edge in the graph and is expected to return a `Result<f64>` of
+///   the weight of that edge.
 /// * `alpha` - Attenuation factor. If set to `None`, a default value of 0.1 is used.
 /// * `beta_map` - Immediate neighbourhood weights. Must contain all node indices or be `None`.
 /// * `beta_scalar` - Immediate neighbourhood scalar that replaces `beta_map` in case `beta_map` is None.
-///     Defaults to 1.0 in case `None` is provided.
+///   Defaults to 1.0 in case `None` is provided.
 /// * `max_iter` - The maximum number of iterations in the power method. If
-///     set to `None` a default value of 100 is used.
+///   set to `None` a default value of 100 is used.
 /// * `tol` - The error tolerance used when checking for convergence in the
-///     power method. If set to `None` a default value of 1e-6 is used.
+///   power method. If set to `None` a default value of 1e-6 is used.
 ///
 /// # Example
 /// ```rust
@@ -1170,9 +1170,9 @@ where
 /// * `graph` - The graph object to run the algorithm on
 /// * `wf_improved` - If `true`, scale by the fraction of nodes reachable.
 /// * `weight_fn` - An input callable that will be passed the
-///     `ReversedEdgeReference<<G as IntoEdgeReferences>::EdgeRef>` for
-///     an edge in the graph and is expected to return a `f64` of
-///     the weight of that edge.
+///   `ReversedEdgeReference<<G as IntoEdgeReferences>::EdgeRef>` for
+///   an edge in the graph and is expected to return a `f64` of
+///   the weight of that edge.
 ///
 /// # Example
 ///

rustworkx-core/src/coloring.rs

@@ -402,9 +402,9 @@ where
 ///
 /// * `graph` - The graph object to run the algorithm on
 /// * `preset_color_fn` - A callback function that will receive the node identifier
-///     for each node in the graph and is expected to return an `Option<usize>`
-///     (wrapped in a `Result`) that is `None` if the node has no preset and
-///     the usize represents the preset color.
+///   for each node in the graph and is expected to return an `Option<usize>`
+///   (wrapped in a `Result`) that is `None` if the node has no preset and
+///   the usize represents the preset color.
 ///
 /// # Example
 /// ```rust
@@ -468,9 +468,9 @@ where
 ///
 /// * `graph` - The graph object to run the algorithm on.
 /// * `preset_color_fn` - A callback function that will receive the node identifier
-///     for each node in the graph and is expected to return an `Option<usize>`
-///     (wrapped in a `Result`) that is `None` if the node has no preset and
-///     the usize represents the preset color.
+///   for each node in the graph and is expected to return an `Option<usize>`
+///   (wrapped in a `Result`) that is `None` if the node has no preset and
+///   the usize represents the preset color.
 /// * `strategy` - The greedy strategy used by the algorithm.
 ///
 /// # Example
@@ -581,9 +581,9 @@ where
 ///
 /// * `graph` - The graph object to run the algorithm on.
 /// * `preset_color_fn` - A callback function that will receive the edge identifier
-///     for each edge in the graph and is expected to return an `Option<usize>`
-///     (wrapped in a `Result`) that is `None` if the edge has no preset and
-///     the usize represents the preset color.
+///   for each edge in the graph and is expected to return an `Option<usize>`
+///   (wrapped in a `Result`) that is `None` if the edge has no preset and
+///   the usize represents the preset color.
 /// * `strategy` - The greedy strategy used by the algorithm.
 ///
 /// # Example

rustworkx-core/src/connectivity/cycle_basis.rs

@@ -34,7 +34,7 @@ use std::hash::Hash;
 ///
 /// * `graph` - The graph in which to find the basis.
 /// * `root` - Optional node index for starting the basis search. If not
-///     specified, an arbitrary node is chosen.
+///   specified, an arbitrary node is chosen.
 ///
 /// # Example
 /// ```rust

rustworkx-core/src/connectivity/find_cycle.rs

@@ -25,7 +25,7 @@ use std::hash::Hash;
 ///
 /// * `graph` - The directed graph in which to find the first cycle.
 /// * `source` - Optional node index for starting the search. If not specified,
-///     an arbitrary node is chosen to start the search.
+///   an arbitrary node is chosen to start the search.
 ///
 /// # Example
 /// ```rust

rustworkx-core/src/dag_algo.rs

@@ -80,19 +80,19 @@ impl<E: Error> Error for TopologicalSortError<E> {}
 ///
 /// * `dag`: The DAG to get the topological sorted nodes from
 /// * `key`: A function that gets passed a single argument, the node id from
-///     `dag` and is expected to return a key which will be used for
-///     resolving ties in the sorting order.
+///   `dag` and is expected to return a key which will be used for
+///   resolving ties in the sorting order.
 /// * `reverse`: If `false`, perform a regular topological ordering.  If `true`,
-///     return the lexicographical topological order that would have been found
-///     if all the edges in the graph were reversed.  This does not affect the
-///     comparisons from the `key`.
+///   return the lexicographical topological order that would have been found
+///   if all the edges in the graph were reversed.  This does not affect the
+///   comparisons from the `key`.
 /// * `initial`: If given, the initial node indices to start the topological
-///     ordering from.  If not given, the topological ordering will certainly contain every node in
-///     the graph.  If given, only the `initial` nodes and nodes that are dominated by the
-///     `initial` set will be in the ordering.  Notably, any node that has a natural in degree of
-///     zero will not be in the output ordering if `initial` is given and the zero-in-degree node
-///     is not in it.  It is not supported to give an `initial` set where the nodes have even
-///     a partial topological order between themselves and `None` will be returned in this case
+///   ordering from.  If not given, the topological ordering will certainly contain every node in
+///   the graph.  If given, only the `initial` nodes and nodes that are dominated by the
+///   `initial` set will be in the ordering.  Notably, any node that has a natural in degree of
+///   zero will not be in the output ordering if `initial` is given and the zero-in-degree node
+///   is not in it.  It is not supported to give an `initial` set where the nodes have even
+///   a partial topological order between themselves and `None` will be returned in this case
 ///
 /// # Returns
 ///
@@ -348,7 +348,7 @@ where
 ///
 /// * `graph` - The graph to get the layers from
 /// * `first_layer` - A list of node ids for the first layer. This
-///     will be the first layer in the output
+///   will be the first layer in the output
 ///
 /// Will `panic!` if a provided node is not in the graph.
 /// ```
@@ -503,20 +503,20 @@ where
 ///
 /// * `graph`: The DAG to find bicolor runs in
 /// * `filter_fn`: The filter function to use for matching nodes. It takes
-///     in one argument, the node data payload/weight object, and will return a
-///     boolean whether the node matches the conditions or not.
-///     If it returns ``true``, it will continue the bicolor chain.
-///     If it returns ``false``, it will stop the bicolor chain.
-///     If it returns ``None`` it will skip that node.
+///   in one argument, the node data payload/weight object, and will return a
+///   boolean whether the node matches the conditions or not.
+///   If it returns ``true``, it will continue the bicolor chain.
+///   If it returns ``false``, it will stop the bicolor chain.
+///   If it returns ``None`` it will skip that node.
 /// * `color_fn`: The function that gives the color of the edge. It takes
-///     in one argument, the edge data payload/weight object, and will
-///     return a non-negative integer, the edge color. If the color is None,
-///     the edge is ignored.
+///   in one argument, the edge data payload/weight object, and will
+///   return a non-negative integer, the edge color. If the color is None,
+///   the edge is ignored.
 ///
 /// # Returns:
 ///
 /// * `Vec<Vec<G::NodeId>>`: a list of groups with exactly two edge colors, where each group
-///     is a list of node data payload/weight for the nodes in the bicolor run
+///   is a list of node data payload/weight for the nodes in the bicolor run
 /// * `None` if a cycle is found in the graph
 /// * Raises an error if found computing the bicolor runs
 ///
@@ -665,9 +665,9 @@ where
 ///
 /// * `graph`: The DAG to collect runs from
 /// * `include_node_fn`: A filter function used for matching nodes. It takes
-///     in one argument, the node data payload/weight object, and returns a
-///     boolean whether the node matches the conditions or not.
-///     If it returns ``false``, the node will be skipped, cutting the run it's part of.
+///   in one argument, the node data payload/weight object, and returns a
+///   boolean whether the node matches the conditions or not.
+///   If it returns ``false``, the node will be skipped, cutting the run it's part of.
 ///
 /// # Returns:
 ///

rustworkx-core/src/generators/barbell_graph.rs

@@ -28,23 +28,23 @@ use crate::utils::pairwise;
 /// Arguments:
 ///
 /// * `num_mesh_nodes` - The number of nodes to generate the mesh graph
-///     with. Node weights will be None if this is specified. If both
-///     `num_mesh_nodes` and `mesh_weights` are set, this will be ignored and
-///     `mesh_weights` will be used.
+///   with. Node weights will be None if this is specified. If both
+///   `num_mesh_nodes` and `mesh_weights` are set, this will be ignored and
+///   `mesh_weights` will be used.
 /// * `num_path_nodes` - The number of nodes to generate the path
-///     with. Node weights will be None if this is specified. If both
-///     `num_path_nodes` and `path_weights` are set, this will be ignored and
-///     `path_weights` will be used.
+///   with. Node weights will be None if this is specified. If both
+///   `num_path_nodes` and `path_weights` are set, this will be ignored and
+///   `path_weights` will be used.
 /// * `mesh_weights` - A list of node weights for the mesh graph. If both
-///     `num_mesh_nodes` and `mesh_weights` are set, `num_mesh_nodes` will
-///     be ignored and `mesh_weights` will be used.
+///   `num_mesh_nodes` and `mesh_weights` are set, `num_mesh_nodes` will
+///   be ignored and `mesh_weights` will be used.
 /// * `path_weights` - A list of node weights for the path. If both
-///     `num_path_nodes` and `path_weights` are set, `num_path_nodes` will
-///     be ignored and `path_weights` will be used.
+///   `num_path_nodes` and `path_weights` are set, `num_path_nodes` will
+///   be ignored and `path_weights` will be used.
 /// * `default_node_weight` - A callable that will return the weight to use
-///     for newly created nodes. This is ignored if node weights are specified.
+///   for newly created nodes. This is ignored if node weights are specified.
 /// * `default_edge_weight` - A callable that will return the weight object
-///     to use for newly created edges.
+///   to use for newly created edges.
 ///
 /// # Example
 /// ```rust

rustworkx-core/src/generators/binomial_tree_graph.rs

@@ -21,14 +21,14 @@ use super::InvalidInputError;
 ///
 /// * `order` - The order of the binomial tree.
 /// * `weights` - A `Vec` of node weight objects. If the number of weights is
-///     less than 2**order, extra nodes with None will be appended.
+///   less than 2**order, extra nodes with None will be appended.
 /// * `default_node_weight` - A callable that will return the weight to use
-///     for newly created nodes. This is ignored if `weights` is specified.
+///   for newly created nodes. This is ignored if `weights` is specified.
 /// * `default_edge_weight` - A callable that will return the weight object
-///     to use for newly created edges.
+///   to use for newly created edges.
 /// * `bidirectional` - Whether edges are added bidirectionally. If set to
-///     `true` then for any edge `(u, v)` an edge `(v, u)` will also be added.
-///     If the graph is undirected this will result in a parallel edge.
+///   `true` then for any edge `(u, v)` an edge `(v, u)` will also be added.
+///   If the graph is undirected this will result in a parallel edge.
 ///
 /// # Example
 /// ```rust

rustworkx-core/src/generators/complete_graph.rs

@@ -21,13 +21,13 @@ use super::InvalidInputError;
 /// Arguments:
 ///
 /// * `num_nodes` - The number of nodes to create a complete graph for. Either this or
-///     `weights` must be specified. If both this and `weights` are specified, `weights`
-///     will take priority and this argument will be ignored
+///   `weights` must be specified. If both this and `weights` are specified, `weights`
+///   will take priority and this argument will be ignored
 /// * `weights` - A `Vec` of node weight objects.
 /// * `default_node_weight` - A callable that will return the weight to use
-///     for newly created nodes. This is ignored if `weights` is specified.
+///   for newly created nodes. This is ignored if `weights` is specified.
 /// * `default_edge_weight` - A callable that will return the weight object
-///     to use for newly created edges.
+///   to use for newly created edges.
 ///
 /// # Example
 /// ```rust

rustworkx-core/src/generators/cycle_graph.rs

@@ -21,16 +21,16 @@ use super::InvalidInputError;
 /// Arguments:
 ///
 /// * `num_nodes` - The number of nodes to create a cycle graph for. Either this or
-///     `weights` must be specified. If both this and `weights` are specified, `weights`
-///     will take priority and this argument will be ignored.
+///   `weights` must be specified. If both this and `weights` are specified, `weights`
+///   will take priority and this argument will be ignored.
 /// * `weights` - A `Vec` of node weight objects.
 /// * `default_node_weight` - A callable that will return the weight to use
-///     for newly created nodes. This is ignored if `weights` is specified.
+///   for newly created nodes. This is ignored if `weights` is specified.
 /// * `default_edge_weight` - A callable that will return the weight object
-///     to use for newly created edges.
+///   to use for newly created edges.
 /// * `bidirectional` - Whether edges are added bidirectionally. If set to
-///     `true` then for any edge `(u, v)` an edge `(v, u)` will also be added.
-///     If the graph is undirected this will result in a parallel edge.
+///   `true` then for any edge `(u, v)` an edge `(v, u)` will also be added.
+///   If the graph is undirected this will result in a parallel edge.
 ///
 /// # Example
 /// ```rust