remove unwanted changes

Author: lmondada

hugr-core/src/hugr/persistent/trait_impls.rs

@@ -35,15 +35,15 @@ use super::root_checked::RootCheckable;
 ///
 /// A HUGR region in which all nodes share the same parent. Unlike
 /// [`super::SiblingGraph`],  not all nodes of the sibling graph must be
-/// included. A convex subgraph is always an induced subgraph, i.e. it is
-/// defined by a set of nodes and all edges between them.
+/// included. A convex subgraph is always an induced subgraph, i.e. it is defined
+/// by a set of nodes and all edges between them.
 ///
 /// The incoming boundary (resp. outgoing boundary) is given by the input (resp.
-/// output) ports of the subgraph that are linked to nodes outside of the
-/// subgraph. The signature of the subgraph is then given by the types of the
-/// incoming and outgoing boundary ports. Given a replacement with the same
-/// signature, a [`SimpleReplacement`] can be constructed to rewrite the
-/// subgraph with the replacement.
+/// output) ports of the subgraph that are linked to nodes outside of the subgraph.
+/// The signature of the subgraph is then given by the types of the incoming
+/// and outgoing boundary ports. Given a replacement with the same signature,
+/// a [`SimpleReplacement`] can be constructed to rewrite the subgraph with the
+/// replacement.
 ///
 /// The ordering of the nodes in the subgraph is irrelevant to define the convex
 /// subgraph, but it determines the ordering of the boundary signature.
@@ -150,10 +150,10 @@ impl<N: HugrNode> SiblingSubgraph<N> {
     ///
     /// ## Arguments
     ///
-    /// The `incoming` and `outgoing` arguments give $B_I$ and $B_O$
-    /// respectively. Incoming edges must be given by incoming ports and
-    /// outgoing edges by outgoing ports. The ordering of the incoming and
-    /// outgoing ports defines the signature of the subgraph.
+    /// The `incoming` and `outgoing` arguments give $B_I$ and $B_O$ respectively.
+    /// Incoming edges must be given by incoming ports and outgoing edges by
+    /// outgoing ports. The ordering of the incoming and outgoing ports defines
+    /// the signature of the subgraph.
     ///
     /// Incoming boundary ports must be unique and partitioned by input
     /// parameter: two ports within the same set of the partition must be
@@ -190,8 +190,7 @@ impl<N: HugrNode> SiblingSubgraph<N> {
     ) -> Result<Self, InvalidSubgraph<N>> {
         let pg = hugr.portgraph();
 
-        // Ordering of the edges here is preserved and becomes ordering of the
-        // signature.
+        // Ordering of the edges here is preserved and becomes ordering of the signature.
         let subpg = Subgraph::new_subgraph(pg.clone(), make_boundary(hugr, &inputs, &outputs));
         let nodes = subpg
             .nodes_iter()
@@ -394,12 +393,12 @@ impl<N: HugrNode> SiblingSubgraph<N> {
     /// match the signature of the subgraph.
     ///
     /// May return one of the following five errors
-    ///  - [`InvalidReplacement::InvalidDataflowGraph`]: the replacement graph
-    ///    is not a [`crate::ops::OpTag::DataflowParent`]-rooted graph,
+    ///  - [`InvalidReplacement::InvalidDataflowGraph`]: the replacement
+    ///    graph is not a [`crate::ops::OpTag::DataflowParent`]-rooted graph,
     ///  - [`InvalidReplacement::InvalidSignature`]: the signature of the
     ///    replacement DFG does not match the subgraph signature, or
-    ///  - [`InvalidReplacement::NonConvexSubgraph`]: the sibling subgraph is
-    ///    not convex.
+    ///  - [`InvalidReplacement::NonConvexSubgraph`]: the sibling subgraph is not
+    ///    convex.
     ///
     /// At the moment we do not support state order edges. If any are found in
     /// the replacement graph, this will panic.
@@ -623,10 +622,10 @@ fn get_edge_type<H: HugrView, P: Into<Port> + Copy>(
 
 /// Whether a subgraph is valid.
 ///
-/// Verifies that input and output ports are valid subgraph boundaries, i.e.
-/// they belong to nodes within the subgraph and are linked to at least one node
-/// outside of the subgraph. This does NOT check convexity proper, i.e. whether
-/// the set of nodes form a convex induced graph.
+/// Verifies that input and output ports are valid subgraph boundaries, i.e. they belong
+/// to nodes within the subgraph and are linked to at least one node outside of the subgraph.
+/// This does NOT check convexity proper, i.e. whether the set of nodes form a convex
+/// induced graph.
 fn validate_subgraph<H: HugrView>(
     hugr: &H,
     nodes: &[H::Node],
@@ -676,8 +675,8 @@ fn validate_subgraph<H: HugrView>(
         Err(InvalidSubgraphBoundary::DisconnectedBoundaryPort(n, p))?;
     };
 
-    // Check that every incoming port of a node in the subgraph whose source is not
-    // in the subgraph belongs to inputs.
+    // Check that every incoming port of a node in the subgraph whose source is not in the subgraph
+    // belongs to inputs.
     if nodes.iter().any(|&n| {
         hugr.node_inputs(n).any(|p| {
             hugr.linked_ports(n, p).any(|(n1, _)| {
@@ -687,8 +686,8 @@ fn validate_subgraph<H: HugrView>(
     }) {
         return Err(InvalidSubgraph::NotConvex);
     }
-    // Check that every outgoing port of a node in the subgraph whose target is not
-    // in the subgraph belongs to outputs.
+    // Check that every outgoing port of a node in the subgraph whose target is not in the subgraph
+    // belongs to outputs.
     if nodes.iter().any(|&n| {
         hugr.node_outputs(n).any(|p| {
             hugr.linked_ports(n, p)
@@ -708,8 +707,7 @@ fn validate_subgraph<H: HugrView>(
         return Err(InvalidSubgraphBoundary::EmptyPartition.into());
     }
 
-    // Check edge types are equal within partition and copyable if partition size >
-    // 1
+    // Check edge types are equal within partition and copyable if partition size > 1
     if let Some((i, _)) = inputs.iter().enumerate().find(|(_, ports)| {
         let Some(edge_t) = get_edge_type(hugr, ports) else {
             return true;
@@ -888,9 +886,9 @@ mod tests {
     impl<N: HugrNode> SiblingSubgraph<N> {
         /// A sibling subgraph from a HUGR.
         ///
-        /// The subgraph is given by the sibling graph of the root. If you wish
-        /// to create a subgraph from another root, wrap the argument
-        /// `region` in a [`super::SiblingGraph`].
+        /// The subgraph is given by the sibling graph of the root. If you wish to
+        /// create a subgraph from another root, wrap the argument `region` in a
+        /// [`super::SiblingGraph`].
         ///
         /// This will return an [`InvalidSubgraph::EmptySubgraph`] error if the
         /// subgraph is empty.
@@ -912,8 +910,7 @@ mod tests {
     }
 
     /// A Module with a single function from three qubits to three qubits.
-    /// The function applies a CX gate to the first two qubits and a Rz gate
-    /// (with a constant angle) to the last qubit.
+    /// The function applies a CX gate to the first two qubits and a Rz gate (with a constant angle) to the last qubit.
     fn build_hugr() -> Result<(Hugr, Node), BuildError> {
         let mut mod_builder = ModuleBuilder::new();
         let func = mod_builder.declare(
@@ -1278,8 +1275,7 @@ mod tests {
         rep.apply(&mut h).unwrap();
     }
 
-    /// Test the behaviour of the sibling subgraph when built from a single
-    /// node.
+    /// Test the behaviour of the sibling subgraph when built from a single node.
     #[test]
     fn single_node_subgraph() {
         // A hugr with a single NOT operation, with disconnected output.
@@ -1293,18 +1289,17 @@ mod tests {
         // Unconnected output, discarded
         let h = b.finish_hugr_with_outputs([]).unwrap();
 
-        // When built with `from_node`, the subgraph's signature is the same as the
-        // node's. (bool input, bool output)
+        // When built with `from_node`, the subgraph's signature is the same as the node's.
+        // (bool input, bool output)
         let subg = SiblingSubgraph::from_node(not_n.node(), &h);
         assert_eq!(subg.nodes().len(), 1);
         assert_eq!(
             subg.signature(&h).io(),
             Signature::new(vec![bool_t()], vec![bool_t()]).io()
         );
 
-        // `from_nodes` is different, is it only uses incoming and outgoing edges to
-        // compute the signature. In this case, the output is disconnected, so
-        // it is not part of the subgraph signature.
+        // `from_nodes` is different, is it only uses incoming and outgoing edges to compute the signature.
+        // In this case, the output is disconnected, so it is not part of the subgraph signature.
         let subg = SiblingSubgraph::try_from_nodes([not_n.node()], &h).unwrap();
         assert_eq!(subg.nodes().len(), 1);
         assert_eq!(