Squashed commit of feat/persistenthugr changes

Author: lmondada

Cargo.lock

@@ -83,6 +83,7 @@ pest_derive = "2.8.0"
 pretty = "0.12.4"
 pretty_assertions = "1.4.1"
 zstd = "0.13.2"
+relrc = "0.4.1"
 
 # These public dependencies usually require breaking changes downstream, so we
 # try to be as permissive as possible.

Cargo.toml

@@ -54,6 +54,7 @@ thiserror = { workspace = true }
 typetag = { workspace = true }
 semver = { workspace = true, features = ["serde"] }
 zstd = { workspace = true, optional = true }
+relrc = { workspace = true, features = ["petgraph"] }
 
 [dev-dependencies]
 rstest = { workspace = true }

hugr-core/Cargo.toml

@@ -5,6 +5,7 @@ pub mod hugrmut;
 pub(crate) mod ident;
 pub mod internal;
 pub mod patch;
+pub mod persistent;
 pub mod serialize;
 pub mod validate;
 pub mod views;

hugr-core/src/hugr.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> {
@@ -392,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> {