switched to outgoing ports

Author: lmondada

hugr-core/src/hugr/patch/simple_replace.rs

@@ -147,6 +147,21 @@ impl<N: HugrNode> OutputBoundaryMap<N> {
             }
         }
     }
+
+    fn map_nodes<M: HugrNode>(&self, node_map: impl Fn(N) -> M) -> OutputBoundaryMap<M> {
+        match self {
+            OutputBoundaryMap::ByIncoming(map) => OutputBoundaryMap::ByIncoming(
+                map.iter()
+                    .map(|(&(node, port), &val)| ((node_map(node), port), val))
+                    .collect(),
+            ),
+            OutputBoundaryMap::ByOutgoing(map) => OutputBoundaryMap::ByOutgoing(
+                map.iter()
+                    .map(|(&(node, port), &val)| ((node_map(node), port), val))
+                    .collect(),
+            ),
+        }
+    }
 }
 
 impl<HostNode: HugrNode> SimpleReplacement<HostNode> {
@@ -361,41 +376,6 @@ impl<HostNode: HugrNode> SimpleReplacement<HostNode> {
         self.nu_inp.get(&(node, port)).copied().map(Into::into)
     }
 
-    /// Map the host nodes in `self` according to `node_map`.
-    ///
-    /// `node_map` must map nodes in the current HUGR of the subgraph to
-    /// its equivalent nodes in some `new_hugr`.
-    ///
-    /// This converts a replacement that acts on nodes of type `HostNode` to
-    /// a replacement that acts on `new_hugr`, with nodes of type `N`.
-    ///
-    /// This does not check convexity. It is up to the caller to ensure that
-    /// the mapped replacement obtained from this applies on a convex subgraph
-    /// of the new HUGR.
-    pub(crate) fn map_host_nodes<N: HugrNode>(
-        &self,
-        node_map: impl Fn(HostNode) -> N,
-    ) -> SimpleReplacement<N> {
-        let Self {
-            subgraph,
-            replacement,
-            nu_inp,
-            nu_out,
-        } = self;
-        let nu_inp = nu_inp
-            .iter()
-            .map(|(&(node, port), &(host_node, host_port))| {
-                ((node, port), (node_map(host_node), host_port))
-            })
-            .collect();
-        let nu_out = nu_out
-            .iter()
-            .map(|(&(host_node, host_port), &port)| ((node_map(host_node), host_port), port))
-            .collect();
-        let subgraph = subgraph.map_nodes(node_map);
-        SimpleReplacement::new(subgraph, replacement.clone(), nu_inp, nu_out)
-    }
-
     /// Get all edges that the replacement would add between `host` and
     /// `self.replacement`.
     ///
@@ -427,6 +407,38 @@ impl<HostNode: HugrNode> SimpleReplacement<HostNode> {
             .chain(outgoing_boundary)
             .chain(host_to_host_boundary)
     }
+
+    /// Map the host nodes in `self` according to `node_map`.
+    ///
+    /// `node_map` must map nodes in the current HUGR of the subgraph to
+    /// its equivalent nodes in some `new_hugr`.
+    ///
+    /// This converts a replacement that acts on nodes of type `HostNode` to
+    /// a replacement that acts on `new_hugr`, with nodes of type `N`.
+    ///
+    /// This does not check convexity. It is up to the caller to ensure that
+    /// the mapped replacement obtained from this applies on a convex subgraph
+    /// of the new HUGR.
+    pub(crate) fn map_host_nodes<N: HugrNode>(
+        &self,
+        node_map: impl Fn(HostNode) -> N,
+    ) -> SimpleReplacement<N> {
+        let Self {
+            subgraph,
+            replacement,
+            nu_inp,
+            nu_out,
+        } = self;
+        let nu_inp = nu_inp
+            .iter()
+            .map(|(&repl_node_port, &(host_node, host_port))| {
+                (repl_node_port, (node_map(host_node), host_port))
+            })
+            .collect();
+        let nu_out = nu_out.map_nodes(&node_map);
+        let subgraph = subgraph.map_nodes(node_map);
+        SimpleReplacement::new(subgraph, replacement.clone(), nu_inp, nu_out)
+    }
 }
 
 impl<HostNode: HugrNode> PatchVerification for SimpleReplacement<HostNode> {

hugr-core/src/hugr/persistent.rs

@@ -139,11 +139,7 @@ impl Commit {
         &self.0
     }
 
-    fn all_parents(&self) -> impl Iterator<Item = &Commit> + '_ {
-        self.0.all_parents().map_into()
-    }
-
-    fn replacement(&self) -> Option<&SimpleReplacement<PatchNode>> {
+    fn replacement(&self) -> Option<&PersistentReplacement> {
         match self.0.value() {
             CommitData::Base(_) => None,
             CommitData::Replacement(replacement) => Some(replacement),
@@ -278,7 +274,7 @@ impl PersistentHugr {
         let new_invalid_nodes = replacement
             .subgraph()
             .nodes()
-            .into_iter()
+            .iter()
             .map(|&PatchNode(id, node)| (id, node))
             .into_grouping_map()
             .collect::<BTreeSet<_>>();

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

@@ -48,7 +48,7 @@ fn simple_hugr() -> (Hugr, [Node; 3]) {
 }
 
 /// Creates a replacement that replaces a node with a sequence of two NOT gates
-fn create_double_not_replacement(hugr: &Hugr, node_to_replace: Node) -> SimpleReplacement {
+fn create_double_not_replacement(hugr: &Hugr, node_to_replace: Node) -> SimpleReplacement<Node> {
     // Create a simple hugr with two NOT gates in sequence
     let mut dfg_builder = DFGBuilder::new(inout_sig(vec![bool_t()], vec![bool_t()])).unwrap();
     let [input_wire] = dfg_builder.input_wires_arr();
@@ -67,11 +67,6 @@ fn create_double_not_replacement(hugr: &Hugr, node_to_replace: Node) -> SimpleRe
 
     let replacement_hugr = dfg_builder.finish_hugr_with_outputs([not2_out]).unwrap();
 
-    // Find the input and output of the node to replace
-    let host_output_target = hugr
-        .single_linked_input(node_to_replace, OutgoingPort::from(0))
-        .unwrap();
-
     // Create the mappings
     let mut nu_inp = HashMap::new();
     nu_inp.insert(
@@ -80,7 +75,10 @@ fn create_double_not_replacement(hugr: &Hugr, node_to_replace: Node) -> SimpleRe
     );
 
     let mut nu_out = HashMap::new();
-    nu_out.insert(host_output_target, IncomingPort::from(0));
+    nu_out.insert(
+        (node_to_replace, OutgoingPort::from(0)),
+        IncomingPort::from(0),
+    );
 
     // Create the subgraph with the single node
     let subgraph = SiblingSubgraph::try_from_nodes(vec![node_to_replace], hugr).unwrap();
@@ -91,7 +89,7 @@ fn create_double_not_replacement(hugr: &Hugr, node_to_replace: Node) -> SimpleRe
 
 /// Creates a replacement that replaces the unique AND gate in `hugr` and its
 /// predecessor NOT gate on 1st input with an XOR gate
-fn create_not_and_to_xor_replacement(hugr: &Hugr) -> SimpleReplacement {
+fn create_not_and_to_xor_replacement(hugr: &Hugr) -> SimpleReplacement<Node> {
     // Create second replacement that replaces the second NOT gate from the first
     // replacement
     // Find the AND gate in the hugr
@@ -133,8 +131,7 @@ fn create_not_and_to_xor_replacement(hugr: &Hugr) -> SimpleReplacement {
 
     // Output mapping - AND gate's output to XOR's output
     let mut nu_out = HashMap::new();
-    let and_output_port = hugr.single_linked_input(and_gate, 0).unwrap();
-    nu_out.insert(and_output_port, IncomingPort::from(0));
+    nu_out.insert((and_gate, OutgoingPort::from(0)), IncomingPort::from(0));
 
     // Create subgraph with both the AND gate and NOT0 node
     let subgraph = SiblingSubgraph::try_from_nodes(vec![not_node, and_gate], &hugr).unwrap();