feat!: Open lists and tuples inTypeArg

hugr-core/Cargo.toml

@@ -63,6 +63,8 @@ semver = { workspace = true, features = ["serde"] }
 zstd = { workspace = true, optional = true }
 ordered-float = { workspace = true, features = ["serde"] }
 base64.workspace = true
+relrc = { workspace = true, features = ["petgraph", "serde"] }
+smallvec = "1.15.0"
 
 [dev-dependencies]
 rstest = { workspace = true }

hugr-core/src/export.rs

@@ -874,6 +874,14 @@ impl<'a> Context<'a> {
                 );
                 self.make_term(table::Term::List(parts))
             }
+            TypeArg::ListConcat { lists } => {
+                let parts = self.bump.alloc_slice_fill_iter(
+                    lists
+                        .iter()
+                        .map(|list| table::SeqPart::Splice(self.export_type_arg(list))),
+                );
+                self.make_term(table::Term::List(parts))
+            }
             TypeArg::Tuple { elems } => {
                 let parts = self.bump.alloc_slice_fill_iter(
                     elems
@@ -882,6 +890,14 @@ impl<'a> Context<'a> {
                 );
                 self.make_term(table::Term::Tuple(parts))
             }
+            TypeArg::TupleConcat { tuples } => {
+                let parts = self.bump.alloc_slice_fill_iter(
+                    tuples
+                        .iter()
+                        .map(|elem| table::SeqPart::Splice(self.export_type_arg(elem))),
+                );
+                self.make_term(table::Term::Tuple(parts))
+            }
             TypeArg::Variable { v } => self.export_type_arg_var(v),
         }
     }

hugr-core/src/extension/resolution/types_mut.rs

@@ -222,14 +222,12 @@ pub(super) fn resolve_typearg_exts(
 ) -> Result<(), ExtensionResolutionError> {
     match arg {
         TypeArg::Type { ty } => resolve_type_exts(node, ty, extensions, used_extensions)?,
-        TypeArg::List { elems } => {
-            for elem in elems.iter_mut() {
-                resolve_typearg_exts(node, elem, extensions, used_extensions)?;
-            }
-        }
-        TypeArg::Tuple { elems } => {
-            for elem in elems.iter_mut() {
-                resolve_typearg_exts(node, elem, extensions, used_extensions)?;
+        TypeArg::List { elems: children }
+        | TypeArg::ListConcat { lists: children }
+        | TypeArg::Tuple { elems: children }
+        | TypeArg::TupleConcat { tuples: children } => {
+            for child in children.iter_mut() {
+                resolve_typearg_exts(node, child, extensions, used_extensions)?;
             }
         }
         _ => {}

hugr-core/src/import.rs

@@ -24,14 +24,15 @@ use crate::{
     },
     types::{
         CustomType, FuncTypeBase, MaybeRV, PolyFuncType, PolyFuncTypeBase, RowVariable, Signature,
-        Type, TypeArg, TypeBase, TypeBound, TypeEnum, TypeName, TypeRow, type_param::TypeParam,
+        Type, TypeArg, TypeBase, TypeBound, TypeEnum, TypeName, TypeRow,
+        type_param::{SeqPart, TypeParam},
         type_row::TypeRowBase,
     },
 };
 use fxhash::FxHashMap;
 use hugr_model::v0 as model;
 use hugr_model::v0::table;
-use itertools::Either;
+use itertools::{Either, Itertools};
 use smol_str::{SmolStr, ToSmolStr};
 use thiserror::Error;
 
@@ -1369,28 +1370,24 @@ impl<'a> Context<'a> {
                     Ok(TypeArg::new_var_use(var.1 as _, decl))
                 }
 
-                table::Term::List { .. } => {
-                    let elems = (|| {
-                        self.import_closed_list(term_id)?
-                            .iter()
-                            .map(|item| self.import_type_arg(*item))
-                            .collect::<Result<_, _>>()
-                    })()
-                    .map_err(|err| error_context!(err, "list items"))?;
-
-                    Ok(TypeArg::List { elems })
+                table::Term::List(parts) => {
+                    // PERFORMANCE: Can we do this without the additional allocation?
+                    let parts: Vec<_> = parts
+                        .iter()
+                        .map(|part| self.import_seq_part(part))
+                        .collect::<Result<_, _>>()
+                        .map_err(|err| error_context!(err, "list parts"))?;
+                    Ok(TypeArg::new_list_from_parts(parts))
                 }
 
-                table::Term::Tuple { .. } => {
-                    let elems = (|| {
-                        self.import_closed_list(term_id)?
-                            .iter()
-                            .map(|item| self.import_type_arg(*item))
-                            .collect::<Result<_, _>>()
-                    })()
-                    .map_err(|err| error_context!(err, "tuple items"))?;
-
-                    Ok(TypeArg::Tuple { elems })
+                table::Term::Tuple(parts) => {
+                    // PERFORMANCE: Can we do this without the additional allocation?
+                    let parts: Vec<_> = parts
+                        .iter()
+                        .map(|part| self.import_seq_part(part))
+                        .try_collect()
+                        .map_err(|err| error_context!(err, "tuple parts"))?;
+                    Ok(TypeArg::new_tuple_from_parts(parts))
                 }
 
                 table::Term::Literal(model::Literal::Str(value)) => Ok(TypeArg::String {
@@ -1420,6 +1417,16 @@ impl<'a> Context<'a> {
         .map_err(|err| error_context!(err, "term {} as `TypeArg`", term_id))
     }
 
+    fn import_seq_part(
+        &mut self,
+        seq_part: &'a table::SeqPart,
+    ) -> Result<SeqPart<TypeArg>, ImportError> {
+        Ok(match seq_part {
+            table::SeqPart::Item(term_id) => SeqPart::Item(self.import_type_arg(*term_id)?),
+            table::SeqPart::Splice(term_id) => SeqPart::Splice(self.import_type_arg(*term_id)?),
+        })
+    }
+
     /// Import a `Type` from a term that represents a runtime type.
     fn import_type<RV: MaybeRV>(
         &mut self,