Import/export functions instead of methods in hugr-core.

Author: zrho

hugr-core/src/envelope.rs

@@ -248,7 +248,7 @@ fn decode_model(
     extension_registry: &ExtensionRegistry,
     format: EnvelopeFormat,
 ) -> Result<Package, EnvelopeError> {
-    use crate::Extension;
+    use crate::{import::import_package, Extension};
     use hugr_model::v0::bumpalo::Bump;
 
     if format.model_version() != Some(0) {
@@ -270,7 +270,7 @@ fn decode_model(
         }
     }
 
-    Ok(Package::from_model(&model_package, &extension_registry)?)
+    Ok(import_package(&model_package, &extension_registry)?)
 }
 
 /// Internal implementation of [`write_envelope`] to call with/without the zstd compression wrapper.
@@ -305,6 +305,8 @@ fn encode_model(
 ) -> Result<(), EnvelopeError> {
     use hugr_model::v0::{binary::write_to_writer, bumpalo::Bump};
 
+    use crate::export::export_package;
+
     if format.model_version() != Some(0) {
         return Err(EnvelopeError::FormatUnsupported {
             format,
@@ -313,7 +315,7 @@ fn encode_model(
     }
 
     let bump = Bump::default();
-    let model_package = package.to_model(&bump);
+    let model_package = export_package(package, &bump);
     write_to_writer(&model_package, &mut writer)?;
 
     if format.append_extensions() {

hugr-core/src/export.rs

@@ -5,6 +5,7 @@ use crate::{
     ops::{
         constant::CustomSerialized, DataflowBlock, DataflowOpTrait, OpName, OpTrait, OpType, Value,
     },
+    package::Package,
     std_extensions::{
         arithmetic::{float_types::ConstF64, int_types::ConstInt},
         collections::array::ArrayValue,
@@ -27,8 +28,18 @@ use hugr_model::v0::{
 use petgraph::unionfind::UnionFind;
 use std::fmt::Write;
 
+/// Export a [`Package`] to its representation in the model.
+pub fn export_package<'a>(package: &'a Package, bump: &'a Bump) -> table::Package<'a> {
+    let modules = package
+        .modules
+        .iter()
+        .map(|module| export_hugr(module, bump))
+        .collect();
+    table::Package { modules }
+}
+
 /// Export a [`Hugr`] graph to its representation in the model.
-pub(crate) fn export_hugr<'a>(hugr: &'a Hugr, bump: &'a Bump) -> table::Module<'a> {
+pub fn export_hugr<'a>(hugr: &'a Hugr, bump: &'a Bump) -> table::Module<'a> {
     let mut ctx = Context::new(hugr, bump);
     ctx.export_root();
     ctx.module

hugr-core/src/hugr.rs

@@ -34,13 +34,6 @@ use crate::ops::{OpTag, OpTrait};
 pub use crate::ops::{OpType, DEFAULT_OPTYPE};
 use crate::{Direction, Node};
 
-#[cfg(feature = "model_unstable")]
-use crate::export::export_hugr;
-#[cfg(feature = "model_unstable")]
-use crate::import::{import_hugr, ImportError};
-#[cfg(feature = "model_unstable")]
-use hugr_model::v0 as model;
-
 /// The Hugr data structure.
 #[derive(Clone, Debug, PartialEq)]
 pub struct Hugr {
@@ -263,21 +256,6 @@ impl Hugr {
         self.extensions = used_extensions;
         Ok(())
     }
-
-    /// Export this module to the model representation.
-    #[cfg(feature = "model_unstable")]
-    pub fn to_model<'a>(&'a self, bump: &'a model::bumpalo::Bump) -> model::table::Module<'a> {
-        export_hugr(self, bump)
-    }
-
-    /// Import a module from the model representation.
-    #[cfg(feature = "model_unstable")]
-    pub fn from_model<'a>(
-        module: &'a model::table::Module<'a>,
-        extensions: &ExtensionRegistry,
-    ) -> Result<Self, ImportError> {
-        import_hugr(module, extensions)
-    }
 }
 
 /// Internal API for HUGRs, not intended for use by users.

hugr-core/src/import.rs

@@ -14,6 +14,7 @@ use crate::{
         ExitBlock, FuncDecl, FuncDefn, Input, LoadConstant, LoadFunction, Module, OpType, OpaqueOp,
         Output, Tag, TailLoop, Value, CFG, DFG,
     },
+    package::Package,
     std_extensions::{
         arithmetic::{float_types::ConstF64, int_types::ConstInt},
         collections::array::ArrayValue,
@@ -79,8 +80,24 @@ macro_rules! error_uninferred {
     ($($e:expr),*) => { ImportError::Uninferred(format!($($e),*)) }
 }
 
-/// Import a `hugr` module from its model representation.
-pub(crate) fn import_hugr(
+/// Import a [`Package`] from its model representation.
+pub fn import_package(
+    package: &table::Package,
+    extensions: &ExtensionRegistry,
+) -> Result<Package, ImportError> {
+    let modules = package
+        .modules
+        .iter()
+        .map(|module| import_hugr(module, extensions))
+        .collect::<Result<Vec<_>, _>>()?;
+
+    // This does not panic since the import already requires a module root.
+    let package = Package::new(modules).expect("non-module root");
+    Ok(package)
+}
+
+/// Import a [`Hugr`] module from its model representation.
+pub fn import_hugr(
     module: &table::Module,
     extensions: &ExtensionRegistry,
 ) -> Result<Hugr, ImportError> {

hugr-core/src/package.rs

@@ -14,11 +14,6 @@ use crate::hugr::{ExtensionError, HugrView, ValidationError};
 use crate::ops::{FuncDefn, Module, NamedOp, OpTag, OpTrait, OpType};
 use crate::{Extension, Hugr};
 
-#[cfg(feature = "model_unstable")]
-use crate::import::ImportError;
-#[cfg(feature = "model_unstable")]
-use hugr_model::v0 as model;
-
 #[derive(Debug, Default, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 /// Package of module HUGRs.
 pub struct Package {
@@ -313,34 +308,6 @@ impl Package {
         #[allow(deprecated)]
         self.to_json_writer(writer)
     }
-
-    /// Export this package to the model representation.
-    #[cfg(feature = "model_unstable")]
-    pub fn to_model<'a>(&'a self, bump: &'a model::bumpalo::Bump) -> model::table::Package<'a> {
-        let modules = self
-            .modules
-            .iter()
-            .map(|module| module.to_model(bump))
-            .collect();
-        model::table::Package { modules }
-    }
-
-    /// Import a package from the model representation.
-    #[cfg(feature = "model_unstable")]
-    pub fn from_model<'a>(
-        package: &'a model::table::Package<'a>,
-        extensions: &ExtensionRegistry,
-    ) -> Result<Self, ImportError> {
-        let modules = package
-            .modules
-            .iter()
-            .map(|module| Hugr::from_model(module, extensions))
-            .collect::<Result<Vec<_>, _>>()?;
-
-        // This does not panic since the import already requires a module root.
-        let package = Self::new(modules).expect("non-module root");
-        Ok(package)
-    }
 }
 
 impl AsRef<[Hugr]> for Package {

hugr-core/tests/model.rs

@@ -2,15 +2,16 @@
 
 use std::str::FromStr;
 
-use hugr::{package::Package, std_extensions::std_reg};
+use hugr::std_extensions::std_reg;
+use hugr_core::{export::export_package, import::import_package};
 use hugr_model::v0 as model;
 
 fn roundtrip(source: &str) -> String {
     let bump = model::bumpalo::Bump::new();
     let package_ast = model::ast::Package::from_str(source).unwrap();
     let package_table = package_ast.resolve(&bump).unwrap();
-    let core = Package::from_model(&package_table, &std_reg()).unwrap();
-    let exported_table = core.to_model(&bump);
+    let core = import_package(&package_table, &std_reg()).unwrap();
+    let exported_table = export_package(&core, &bump);
     let exported_ast = exported_table.as_ast().unwrap();
     exported_ast.to_string()
 }

hugr/benches/benchmarks/hugr.rs

@@ -31,7 +31,7 @@ struct CapnpSer;
 impl Serializer for CapnpSer {
     fn serialize(&self, hugr: &Hugr) -> Vec<u8> {
         let bump = bumpalo::Bump::new();
-        let module = hugr.to_model(&bump);
+        let module = hugr_core::export::export_hugr(hugr, &bump);
         let package = hugr_model::v0::table::Package {
             modules: vec![module],
         };
@@ -41,7 +41,7 @@ impl Serializer for CapnpSer {
     fn deserialize(&self, bytes: &[u8]) -> Hugr {
         let bump = bumpalo::Bump::new();
         let package = hugr_model::v0::binary::read_from_slice(bytes, &bump).unwrap();
-        Hugr::from_model(&package.modules[0], &STD_REG).unwrap()
+        hugr_core::import::import_hugr(&package.modules[0], &STD_REG).unwrap()
     }
 }