feat!: Split TypeArg::Sequence into tuples and lists.

hugr-core/Cargo.toml

@@ -21,6 +21,7 @@ extension_inference = []
 declarative = ["serde_yaml"]
 model_unstable = ["hugr-model"]
 zstd = ["dep:zstd"]
+default = ["model_unstable"]
 
 [lib]
 bench = false

hugr-core/src/export.rs

@@ -822,15 +822,22 @@ impl<'a> Context<'a> {
             TypeArg::Type { ty } => self.export_type(ty),
             TypeArg::BoundedNat { n } => self.make_term(model::Literal::Nat(*n).into()),
             TypeArg::String { arg } => self.make_term(model::Literal::Str(arg.into()).into()),
-            TypeArg::Sequence { elems } => {
-                // For now we assume that the sequence is meant to be a list.
+            TypeArg::List { elems } => {
                 let parts = self.bump.alloc_slice_fill_iter(
                     elems
                         .iter()
                         .map(|elem| table::SeqPart::Item(self.export_type_arg(elem))),
                 );
                 self.make_term(table::Term::List(parts))
             }
+            TypeArg::Tuple { elems } => {
+                let parts = self.bump.alloc_slice_fill_iter(
+                    elems
+                        .iter()
+                        .map(|elem| table::SeqPart::Item(self.export_type_arg(elem))),
+                );
+                self.make_term(table::Term::Tuple(parts))
+            }
             TypeArg::Extensions { .. } => self.make_term_apply("compat.ext_set", &[]),
             TypeArg::Variable { v } => self.export_type_arg_var(v),
         }

hugr-core/src/extension/prelude.rs

@@ -678,7 +678,7 @@ impl MakeExtensionOp for MakeTuple {
         if def != TupleOpDef::MakeTuple {
             return Err(OpLoadError::NotMember(ext_op.def().name().to_string()))?;
         }
-        let [TypeArg::Sequence { elems }] = ext_op.args() else {
+        let [TypeArg::List { elems }] = ext_op.args() else {
             return Err(SignatureError::InvalidTypeArgs)?;
         };
         let tys: Result<Vec<Type>, _> = elems
@@ -692,7 +692,7 @@ impl MakeExtensionOp for MakeTuple {
     }
 
     fn type_args(&self) -> Vec<TypeArg> {
-        vec![TypeArg::Sequence {
+        vec![TypeArg::List {
             elems: self
                 .0
                 .iter()
@@ -740,7 +740,7 @@ impl MakeExtensionOp for UnpackTuple {
         if def != TupleOpDef::UnpackTuple {
             return Err(OpLoadError::NotMember(ext_op.def().name().to_string()))?;
         }
-        let [TypeArg::Sequence { elems }] = ext_op.args() else {
+        let [TypeArg::List { elems }] = ext_op.args() else {
             return Err(SignatureError::InvalidTypeArgs)?;
         };
         let tys: Result<Vec<Type>, _> = elems
@@ -754,7 +754,7 @@ impl MakeExtensionOp for UnpackTuple {
     }
 
     fn type_args(&self) -> Vec<TypeArg> {
-        vec![TypeArg::Sequence {
+        vec![TypeArg::List {
             elems: self
                 .0
                 .iter()
@@ -965,7 +965,7 @@ impl MakeExtensionOp for Barrier {
     {
         let _def = BarrierDef::from_def(ext_op.def())?;
 
-        let [TypeArg::Sequence { elems }] = ext_op.args() else {
+        let [TypeArg::List { elems }] = ext_op.args() else {
             return Err(SignatureError::InvalidTypeArgs)?;
         };
         let tys: Result<Vec<Type>, _> = elems
@@ -981,7 +981,7 @@ impl MakeExtensionOp for Barrier {
     }
 
     fn type_args(&self) -> Vec<TypeArg> {
-        vec![TypeArg::Sequence {
+        vec![TypeArg::List {
             elems: self
                 .type_row
                 .iter()
@@ -1132,7 +1132,7 @@ mod test {
 
         let err = b.add_load_value(error_val);
 
-        const TYPE_ARG_NONE: TypeArg = TypeArg::Sequence { elems: vec![] };
+        const TYPE_ARG_NONE: TypeArg = TypeArg::List { elems: vec![] };
         let op = PRELUDE
             .instantiate_extension_op(&EXIT_OP_ID, [TYPE_ARG_NONE, TYPE_ARG_NONE])
             .unwrap();
@@ -1147,7 +1147,7 @@ mod test {
     fn test_panic_with_io() {
         let error_val = ConstError::new(42, "PANIC");
         let type_arg_q: TypeArg = TypeArg::Type { ty: qb_t() };
-        let type_arg_2q: TypeArg = TypeArg::Sequence {
+        let type_arg_2q: TypeArg = TypeArg::List {
             elems: vec![type_arg_q.clone(), type_arg_q],
         };
         let panic_op = PRELUDE

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

@@ -216,7 +216,12 @@ pub(super) fn collect_typearg_exts(
 ) {
     match arg {
         TypeArg::Type { ty } => collect_type_exts(ty, used_extensions, missing_extensions),
-        TypeArg::Sequence { elems } => {
+        TypeArg::List { elems } => {
+            for elem in elems.iter() {
+                collect_typearg_exts(elem, used_extensions, missing_extensions);
+            }
+        }
+        TypeArg::Tuple { elems } => {
             for elem in elems.iter() {
                 collect_typearg_exts(elem, used_extensions, missing_extensions);
             }

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

@@ -214,7 +214,12 @@ pub(super) fn resolve_typearg_exts(
 ) -> Result<(), ExtensionResolutionError> {
     match arg {
         TypeArg::Type { ty } => resolve_type_exts(node, ty, extensions, used_extensions)?,
-        TypeArg::Sequence { elems } => {
+        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)?;
             }

hugr-core/src/hugr.rs

@@ -458,7 +458,7 @@ mod test {
                     TypeArg::Extensions {
                         es: extensions.into(),
                     },
-                    TypeArg::Sequence {
+                    TypeArg::List {
                         elems: type_row
                             .into()
                             .iter()

hugr-core/src/hugr/validate/test.rs

@@ -639,8 +639,8 @@ fn instantiate_row_variables() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
-fn seq1ty(t: TypeRV) -> TypeArg {
-    TypeArg::Sequence {
+fn list1ty(t: TypeRV) -> TypeArg {
+    TypeArg::List {
         elems: vec![t.into()],
     }
 }
@@ -668,7 +668,7 @@ fn row_variables() -> Result<(), Box<dyn std::error::Error>> {
     };
     let par = e.instantiate_extension_op(
         "parallel",
-        [tv.clone(), usize_t().into(), tv.clone(), usize_t().into()].map(seq1ty),
+        [tv.clone(), usize_t().into(), tv.clone(), usize_t().into()].map(list1ty),
     )?;
     let par_func = fb.add_dataflow_op(par, [func_arg, id_usz])?;
     fb.finish_hugr_with_outputs(par_func.outputs())?;

hugr-core/src/import.rs

@@ -1202,14 +1202,17 @@ impl<'a> Context<'a> {
                     .map(|item| self.import_type_arg(*item))
                     .collect::<Result<_, _>>()?;
 
-                Ok(TypeArg::Sequence { elems })
+                Ok(TypeArg::List { elems })
             }
 
             table::Term::Tuple { .. } => {
-                // NOTE: While `TypeArg`s can represent tuples as
-                // `TypeArg::Sequence`s, this conflates lists and tuples. To
-                // avoid ambiguity we therefore report an error here for now.
-                Err(error_unsupported!("tuples as `TypeArg`"))
+                let elems = self
+                    .import_closed_list(term_id)?
+                    .iter()
+                    .map(|item| self.import_type_arg(*item))
+                    .collect::<Result<_, _>>()?;
+
+                Ok(TypeArg::Tuple { elems })
             }
 
             table::Term::Literal(model::Literal::Str(value)) => Ok(TypeArg::String {

hugr-core/src/ops/controlflow.rs

@@ -417,7 +417,7 @@ mod test {
             extension_delta: ExtensionSet::new(),
         };
         let cond2 = cond.substitute(&Substitution::new(&[
-            TypeArg::Sequence {
+            TypeArg::List {
                 elems: vec![usize_t().into(); 3],
             },
             qb_t().into(),

hugr-core/src/std_extensions/collections/array/array_scan.rs

@@ -188,7 +188,7 @@ impl MakeExtensionOp for ArrayScan {
             TypeArg::BoundedNat { n: self.size },
             self.src_ty.clone().into(),
             self.tgt_ty.clone().into(),
-            TypeArg::Sequence {
+            TypeArg::List {
                 elems: self.acc_tys.clone().into_iter().map_into().collect(),
             },
             TypeArg::Extensions {
@@ -217,7 +217,7 @@ impl HasConcrete for ArrayScanDef {
 
     fn instantiate(&self, type_args: &[TypeArg]) -> Result<Self::Concrete, OpLoadError> {
         match type_args {
-            [TypeArg::BoundedNat { n }, TypeArg::Type { ty: src_ty }, TypeArg::Type { ty: tgt_ty }, TypeArg::Sequence { elems: acc_tys }, TypeArg::Extensions { es }] =>
+            [TypeArg::BoundedNat { n }, TypeArg::Type { ty: src_ty }, TypeArg::Type { ty: tgt_ty }, TypeArg::List { elems: acc_tys }, TypeArg::Extensions { es }] =>
             {
                 let acc_tys: Result<_, OpLoadError> = acc_tys
                     .iter()

hugr-core/src/types.rs

@@ -689,7 +689,7 @@ impl<'a> Substitution<'a> {
             .expect("Undeclared type variable - call validate() ?");
         debug_assert!(check_type_arg(arg, &TypeParam::new_list(bound)).is_ok());
         match arg {
-            TypeArg::Sequence { elems } => elems
+            TypeArg::List { elems } => elems
                 .iter()
                 .map(|ta| {
                     match ta {
@@ -932,7 +932,7 @@ pub(crate) mod test {
 
         let coln = e.get_type(&COLN).unwrap();
         let c_of_cpy = coln
-            .instantiate([TypeArg::Sequence {
+            .instantiate([TypeArg::List {
                 elems: vec![Type::from(cpy.clone()).into()],
             }])
             .unwrap();
@@ -947,7 +947,7 @@ pub(crate) mod test {
         );
 
         let mut t = Type::new_extension(
-            coln.instantiate([TypeArg::Sequence {
+            coln.instantiate([TypeArg::List {
                 elems: vec![mk_opt(Type::from(cpy.clone())).into()],
             }])
             .unwrap(),
@@ -966,7 +966,7 @@ pub(crate) mod test {
             (ct == &c_of_cpy).then_some(usize_t())
         });
         let mut t = Type::new_extension(
-            coln.instantiate([TypeArg::Sequence {
+            coln.instantiate([TypeArg::List {
                 elems: vec![Type::from(c_of_cpy.clone()).into(); 2],
             }])
             .unwrap(),
@@ -975,7 +975,7 @@ pub(crate) mod test {
         assert_eq!(
             t,
             Type::new_extension(
-                coln.instantiate([TypeArg::Sequence {
+                coln.instantiate([TypeArg::List {
                     elems: vec![usize_t().into(); 2]
                 }])
                 .unwrap()

hugr-core/src/types/poly_func.rs

@@ -437,14 +437,12 @@ pub(crate) mod test {
         }
         pf.instantiate(&[TypeArg::Type { ty: usize_t() }])
             .unwrap_err();
-        pf.instantiate(&[TypeArg::Sequence {
-            elems: vec![usize_t().into(), TypeArg::Sequence { elems: seq2() }],
+        pf.instantiate(&[TypeArg::List {
+            elems: vec![usize_t().into(), TypeArg::List { elems: seq2() }],
         }])
         .unwrap_err();
 
-        let t2 = pf
-            .instantiate(&[TypeArg::Sequence { elems: seq2() }])
-            .unwrap();
+        let t2 = pf.instantiate(&[TypeArg::List { elems: seq2() }]).unwrap();
         assert_eq!(
             t2,
             Signature::new(
@@ -472,7 +470,7 @@ pub(crate) mod test {
 
         let inner3 = Type::new_function(Signature::new_endo(vec![usize_t(), bool_t(), usize_t()]));
         let t3 = pf
-            .instantiate(&[TypeArg::Sequence {
+            .instantiate(&[TypeArg::List {
                 elems: vec![usize_t().into(), bool_t().into(), usize_t().into()],
             }])
             .unwrap();