feat!: Allow "Row Variables" declared as List<Type>

src/extension.rs

@@ -123,6 +123,9 @@ pub enum SignatureError {
     /// A type variable that was used has not been declared
     #[error("Type variable {idx} was not declared ({num_decls} in scope)")]
     FreeTypeVar { idx: usize, num_decls: usize },
+    /// A row variable was found outside of a row
+    #[error("Row variable {idx} was found outside of a type row")]
+    RowTypeVarOutsideRow { idx: usize },
     /// The type stored in a [LeafOp::TypeApply] is not what we compute from the
     /// [ExtensionRegistry].
     ///

src/hugr/validate/test.rs

@@ -4,6 +4,7 @@ use super::*;
 use crate::builder::test::closed_dfg_root_hugr;
 use crate::builder::{
     BuildError, Container, Dataflow, DataflowHugr, DataflowSubContainer, FunctionBuilder,
+    HugrBuilder,
 };
 use crate::extension::prelude::{BOOL_T, PRELUDE, USIZE_T};
 use crate::extension::{
@@ -559,6 +560,53 @@ fn no_polymorphic_consts() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
+#[test]
+fn inner_row_variables() -> Result<(), Box<dyn std::error::Error>> {
+    let tv = Type::new_row_var(0, TypeBound::Any);
+    let inner_ft = Type::new_function(FunctionType::new_endo(vec![tv]));
+    let mut fb = FunctionBuilder::new(
+        "id",
+        PolyFuncType::new(
+            [TypeParam::List {
+                param: Box::new(TypeParam::Type { b: TypeBound::Any }),
+            }],
+            FunctionType::new_endo(vec![inner_ft.clone()]),
+        ),
+    )?;
+    // All the wires here are carrying higher-order Function values
+    // (the Functions themselves have variable arity, but that's fine as we are not calling them)
+    let id = fb.add_dataflow_op(LeafOp::Noop { ty: inner_ft }, fb.input_wires())?;
+    fb.finish_hugr_with_outputs(id.outputs(), &EMPTY_REG)?;
+    Ok(())
+}
+
+#[test]
+fn no_outer_row_variables() -> Result<(), Box<dyn std::error::Error>> {
+    let tv = Type::new_row_var(0, TypeBound::Any);
+    let fb = FunctionBuilder::new(
+        "impossible_id_of_unknown_arity",
+        PolyFuncType::new(
+            [TypeParam::List {
+                param: Box::new(TypeParam::Type { b: TypeBound::Any }),
+            }],
+            FunctionType::new_endo(vec![tv]),
+        ),
+    )?;
+    // Input and Output nodes have a Port whose type is List(Type(Any))
+    // - so this is illegal because the wire between them is not a type:
+    let err = fb
+        .clone()
+        .finish_hugr_with_outputs(fb.input_wires(), &EMPTY_REG)
+        .unwrap_err();
+    assert_matches!(
+        err,
+        BuildError::InvalidHUGR(ValidationError::SignatureError { .. })
+    );
+    // Also try leaving no inputs/outputs - so this should be illegal because the ports are unconnected
+    fb.finish_hugr(&EMPTY_REG).unwrap_err();
+    Ok(())
+}
+
 #[cfg(feature = "extension_inference")]
 mod extension_tests {
     use super::*;

src/types.rs

@@ -153,10 +153,14 @@ pub enum TypeEnum {
     #[allow(missing_docs)]
     #[display(fmt = "Function({})", "_0")]
     Function(Box<PolyFuncType>),
-    // DeBruijn index, and cache of TypeBound (checked in validation)
+    /// DeBruijn index, and cache of TypeBound of [TypeParam::Type] (checked in validation)
     #[allow(missing_docs)]
     #[display(fmt = "Variable({})", _0)]
     Variable(usize, TypeBound),
+    /// DeBruijn index, and cache of inner TypeBound - matches a [TypeParam::List] of [TypeParam::Type]
+    /// of this bound (checked in validation)
+    #[display(fmt = "RowVar({})", _0)]
+    RowVariable(usize, TypeBound),
     #[allow(missing_docs)]
     #[display(fmt = "Tuple({})", "_0")]
     Tuple(TypeRow),
@@ -171,7 +175,7 @@ impl TypeEnum {
             TypeEnum::Extension(c) => c.bound(),
             TypeEnum::Alias(a) => a.bound,
             TypeEnum::Function(_) => TypeBound::Copyable,
-            TypeEnum::Variable(_, b) => *b,
+            TypeEnum::Variable(_, b) | TypeEnum::RowVariable(_, b) => *b,
             TypeEnum::Sum(SumType::Unit { size: _ }) => TypeBound::Eq,
             TypeEnum::Sum(SumType::General { row }) => {
                 least_upper_bound(row.iter().map(Type::least_upper_bound))
@@ -268,10 +272,17 @@ impl Type {
     /// New use (occurrence) of the type variable with specified DeBruijn index.
     /// For use in type schemes only: `bound` must match that with which the
     /// variable was declared (i.e. as a [TypeParam::Type]`(bound)`).
-    pub fn new_var_use(idx: usize, bound: TypeBound) -> Self {
+    pub const fn new_var_use(idx: usize, bound: TypeBound) -> Self {
         Self(TypeEnum::Variable(idx, bound), bound)
     }
 
+    /// New use (occurrence) of the row variable with specified DeBruijn index.
+    /// For use in type schemes only: `bound` must match that with which the
+    /// variable was declared (i.e. as a [TypeParam::List]`(`[TypeParam::Type]`(bound))`).
+    pub const fn new_row_var(idx: usize, bound: TypeBound) -> Self {
+        Self(TypeEnum::RowVariable(idx, bound), bound)
+    }
+
     /// Report the least upper TypeBound, if there is one.
     #[inline(always)]
     pub const fn least_upper_bound(&self) -> TypeBound {
@@ -305,27 +316,55 @@ impl Type {
         // There is no need to check the components against the bound,
         // that is guaranteed by construction (even for deserialization)
         match &self.0 {
-            TypeEnum::Tuple(row) | TypeEnum::Sum(SumType::General { row }) => row
-                .iter()
-                .try_for_each(|t| t.validate(extension_registry, var_decls)),
+            TypeEnum::Tuple(row) | TypeEnum::Sum(SumType::General { row }) => {
+                valid_row(row, extension_registry, var_decls)
+            }
             TypeEnum::Sum(SumType::Unit { .. }) => Ok(()), // No leaves there
             TypeEnum::Alias(_) => Ok(()),
             TypeEnum::Extension(custy) => custy.validate(extension_registry, var_decls),
             TypeEnum::Function(ft) => ft.validate(extension_registry, var_decls),
             TypeEnum::Variable(idx, bound) => check_typevar_decl(var_decls, *idx, &(*bound).into()),
+            TypeEnum::RowVariable(idx, _) => {
+                Err(SignatureError::RowTypeVarOutsideRow { idx: *idx })
+            }
+        }
+    }
+
+    fn validate_in_row(
+        &self,
+        extension_registry: &ExtensionRegistry,
+        var_decls: &[TypeParam],
+    ) -> Result<(), SignatureError> {
+        if let TypeEnum::RowVariable(idx, bound) = self.0 {
+            let t = TypeParam::List {
+                param: Box::new(bound.into()),
+            };
+            check_typevar_decl(var_decls, idx, &t)
+        } else {
+            self.validate(extension_registry, var_decls)
         }
     }
 
     pub(crate) fn substitute(&self, t: &impl Substitution) -> Self {
         match &self.0 {
             TypeEnum::Alias(_) | TypeEnum::Sum(SumType::Unit { .. }) => self.clone(),
             TypeEnum::Variable(idx, bound) => t.apply_typevar(*idx, *bound),
+            TypeEnum::RowVariable(_, _) => {
+                panic!("Row Variable found outside of row - should have been detected in validate")
+            }
             TypeEnum::Extension(cty) => Type::new_extension(cty.substitute(t)),
             TypeEnum::Function(bf) => Type::new_function(bf.substitute(t)),
             TypeEnum::Tuple(elems) => Type::new_tuple(subst_row(elems, t)),
             TypeEnum::Sum(SumType::General { row }) => Type::new_sum(subst_row(row, t)),
         }
     }
+
+    fn substitute_in_row(&self, t: &impl Substitution) -> Vec<Self> {
+        match &self.0 {
+            TypeEnum::RowVariable(idx, bound) => t.apply_rowvar(*idx, *bound),
+            _ => vec![self.substitute(t)],
+        }
+    }
 }
 
 /// A function that replaces type variables with values.
@@ -344,13 +383,26 @@ pub(crate) trait Substitution {
     /// Apply to a variable whose kind is any given [TypeParam]
     fn apply_var(&self, idx: usize, decl: &TypeParam) -> TypeArg;
 
+    fn apply_rowvar(&self, idx: usize, bound: TypeBound) -> Vec<Type> {
+        vec![self.apply_typevar(idx, bound)]
+    }
+
     fn extension_registry(&self) -> &ExtensionRegistry;
 }
 
+fn valid_row(
+    row: &TypeRow,
+    exts: &ExtensionRegistry,
+    var_decls: &[TypeParam],
+) -> Result<(), SignatureError> {
+    row.iter()
+        .try_for_each(|t| t.validate_in_row(exts, var_decls))
+}
+
 fn subst_row(row: &TypeRow, tr: &impl Substitution) -> TypeRow {
     let res = row
         .iter()
-        .map(|ty| ty.substitute(tr))
+        .flat_map(|ty| ty.substitute_in_row(tr))
         .collect::<Vec<_>>()
         .into();
     res
@@ -399,10 +451,16 @@ pub(crate) mod test {
     pub(crate) use poly_func::test::nested_func;
 
     use super::*;
+    use crate::extension::PRELUDE;
+    use crate::{const_extension_ids, Extension};
     use crate::{extension::prelude::USIZE_T, ops::AliasDecl};
 
     use crate::types::TypeBound;
 
+    const_extension_ids! {
+        const MY_EXT: ExtensionId = "my_extension";
+    }
+
     #[test]
     fn construct() {
         let t: Type = Type::new_tuple(vec![
@@ -411,7 +469,7 @@ pub(crate) mod test {
             Type::new_extension(CustomType::new(
                 "my_custom",
                 [],
-                "my_extension".try_into().unwrap(),
+                MY_EXT,
                 TypeBound::Copyable,
             )),
             Type::new_alias(AliasDecl::new("my_alias", TypeBound::Eq)),
@@ -421,6 +479,17 @@ pub(crate) mod test {
             "Tuple([usize([]), Function(forall . [[]][]), my_custom([]), Alias(my_alias)])"
                 .to_string()
         );
+
+        let mut ext = Extension::new(MY_EXT);
+        ext.add_type(
+            "my_custom".into(),
+            vec![],
+            "".into(),
+            TypeBound::Copyable.into(),
+        )
+        .unwrap();
+        let reg = ExtensionRegistry::try_new([PRELUDE.to_owned(), ext]).unwrap();
+        t.validate(&reg, &[]).unwrap()
     }
 
     #[test]

src/types/poly_func.rs

@@ -7,7 +7,7 @@ use crate::{
 use itertools::Itertools;
 
 use super::type_param::{check_type_args, TypeArg, TypeParam};
-use super::{FunctionType, Substitution};
+use super::{FunctionType, Substitution, Type, TypeBound};
 
 /// A polymorphic function type, e.g. of a [Graph], or perhaps an [OpDef].
 /// (Nodes/operations in the Hugr are not polymorphic.)
@@ -160,6 +160,27 @@ impl<'a> Substitution for SubstValues<'a> {
         arg.clone()
     }
 
+    fn apply_rowvar(&self, idx: usize, bound: TypeBound) -> Vec<Type> {
+        let arg = self
+            .0
+            .get(idx)
+            .expect("Undeclared type variable - call validate() ?");
+        match arg {
+            TypeArg::Sequence { elems } => elems
+                .iter()
+                .map(|ta| match ta {
+                    TypeArg::Type { ty } => ty.clone(),
+                    _ => panic!("Not a list of types - did validate() ?"),
+                })
+                .collect(),
+            TypeArg::Type { ty } => {
+                debug_assert_eq!(check_type_arg(arg, &TypeParam::Type { b: bound }), Ok(()));
+                vec![ty.clone()]
+            }
+            _ => panic!("Not a type or list of types - did validate() ?"),
+        }
+    }
+
     fn extension_registry(&self) -> &ExtensionRegistry {
         self.1
     }
@@ -221,7 +242,7 @@ pub(crate) mod test {
     use lazy_static::lazy_static;
     use smol_str::SmolStr;
 
-    use crate::extension::prelude::{array_type, PRELUDE_ID, USIZE_CUSTOM_T, USIZE_T};
+    use crate::extension::prelude::{array_type, BOOL_T, PRELUDE_ID, USIZE_CUSTOM_T, USIZE_T};
     use crate::extension::{
         ExtensionId, ExtensionRegistry, SignatureError, TypeDefBound, PRELUDE, PRELUDE_REGISTRY,
     };
@@ -618,4 +639,91 @@ pub(crate) mod test {
             )
         )
     }
+
+    #[test]
+    fn row_variables() {
+        const TP: TypeParam = TypeParam::Type { b: TypeBound::Any };
+        // Mismatched TypeBound (Copyable vs Any)
+        PolyFuncType::new_validated(
+            [TypeParam::List {
+                param: Box::new(TypeParam::Type {
+                    b: TypeBound::Copyable,
+                }),
+            }],
+            FunctionType::new(
+                vec![USIZE_T, Type::new_var_use(0, TypeBound::Any)],
+                vec![Type::new_sum(vec![Type::new_row_var(0, TypeBound::Any)])],
+            ),
+            &PRELUDE_REGISTRY,
+        )
+        .unwrap_err();
+
+        let pf = PolyFuncType::new_validated(
+            [TypeParam::List {
+                param: Box::new(TP),
+            }],
+            FunctionType::new(
+                vec![USIZE_T, Type::new_row_var(0, TypeBound::Any)],
+                vec![Type::new_sum(vec![Type::new_row_var(0, TypeBound::Any)])],
+            ),
+            &PRELUDE_REGISTRY,
+        )
+        .unwrap();
+
+        fn seq2() -> Vec<TypeArg> {
+            vec![USIZE_T.into(), BOOL_T.into()]
+        }
+        pf.instantiate(&[TypeArg::Type { ty: USIZE_T }], &PRELUDE_REGISTRY)
+            .unwrap_err();
+        pf.instantiate(
+            &[TypeArg::Sequence {
+                elems: vec![USIZE_T.into(), TypeArg::Sequence { elems: seq2() }],
+            }],
+            &PRELUDE_REGISTRY,
+        )
+        .unwrap_err();
+
+        let t2 = pf
+            .instantiate(&[TypeArg::Sequence { elems: seq2() }], &PRELUDE_REGISTRY)
+            .unwrap();
+        assert_eq!(
+            t2,
+            FunctionType::new(
+                vec![USIZE_T, USIZE_T, BOOL_T],
+                vec![Type::new_sum(vec![USIZE_T, BOOL_T])]
+            )
+        );
+    }
+
+    #[test]
+    fn row_variables_inner() {
+        let inner_fty = Type::new_function(FunctionType::new_endo(vec![Type::new_row_var(
+            0,
+            TypeBound::Copyable,
+        )]));
+        let pf = PolyFuncType::new_validated(
+            [TypeParam::List {
+                param: Box::new(TypeParam::Type {
+                    b: TypeBound::Copyable,
+                }),
+            }],
+            FunctionType::new(vec![USIZE_T, inner_fty.clone()], vec![inner_fty]),
+            &PRELUDE_REGISTRY,
+        )
+        .unwrap();
+
+        let inner3 = Type::new_function(FunctionType::new_endo(vec![USIZE_T, BOOL_T, USIZE_T]));
+        let t3 = pf
+            .instantiate(
+                &[TypeArg::Sequence {
+                    elems: vec![USIZE_T.into(), BOOL_T.into(), USIZE_T.into()],
+                }],
+                &PRELUDE_REGISTRY,
+            )
+            .unwrap();
+        assert_eq!(
+            t3,
+            FunctionType::new(vec![USIZE_T, inner3.clone()], vec![inner3])
+        );
+    }
 }