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

hugr-py/src/hugr/serialization/tys.py

@@ -214,6 +214,15 @@ class Variable(ConfiguredBaseModel):
     b: "TypeBound"
 
 
+class RowVar(ConfiguredBaseModel):
+    """A variable standing for a row of some (unknown) number of types.
+    May occur only within a row; not a node input/output."""
+
+    t: Literal["R"] = "R"
+    i: int
+    b: "TypeBound"
+
+
 class USize(ConfiguredBaseModel):
     """Unsigned integer size type."""
 
@@ -321,7 +330,15 @@ class Type(RootModel):
     """A HUGR type."""
 
     root: Annotated[
-        Qubit | Variable | USize | FunctionType | Array | SumType | Opaque | Alias,
+        Qubit
+        | Variable
+        | RowVar
+        | USize
+        | FunctionType
+        | Array
+        | SumType
+        | Opaque
+        | Alias,
         WrapValidator(_json_custom_error_validator),
         Field(discriminator="t"),
     ]

hugr/src/extension.rs

@@ -161,6 +161,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 variable-length row
+    #[error("Row variable {idx} was found outside of a type row")]
+    RowTypeVarOutsideRow { idx: usize },
     /// The result of the type application stored in a [Call]
     /// is not what we get by applying the type-args to the polymorphic function
     ///

hugr/src/extension/op_def.rs

@@ -405,7 +405,10 @@ impl OpDef {
         // TODO https://github.com/CQCL/hugr/issues/624 validate declared TypeParams
         // for both type scheme and custom binary
         if let SignatureFunc::TypeScheme(ts) = &self.signature_func {
-            ts.poly_func.validate(exts)?;
+            // The type scheme may contain row variables so be of variable length;
+            // these will have to be substituted to fixed-length concrete types when
+            // the OpDef is instantiated into an actual OpType.
+            ts.poly_func.validate_var_len(exts)?;
         }
         Ok(())
     }
@@ -482,6 +485,7 @@ mod test {
     use crate::extension::{SignatureError, EMPTY_REG, PRELUDE_REGISTRY};
     use crate::ops::{CustomOp, OpName};
     use crate::std_extensions::collections::{EXTENSION, LIST_TYPENAME};
+    use crate::types::type_param::TypeArgError;
     use crate::types::Type;
     use crate::types::{type_param::TypeParam, FunctionType, PolyFuncType, TypeArg, TypeBound};
     use crate::{const_extension_ids, Extension};
@@ -639,6 +643,17 @@ mod test {
             def.compute_signature(&args, &EMPTY_REG),
             Ok(FunctionType::new_endo(vec![tv]))
         );
+        // But not with an external row variable
+        let arg: TypeArg = Type::new_row_var_use(0, TypeBound::Eq).into();
+        assert_eq!(
+            def.compute_signature(&[arg.clone()], &EMPTY_REG),
+            Err(SignatureError::TypeArgMismatch(
+                TypeArgError::TypeMismatch {
+                    param: TypeBound::Any.into(),
+                    arg
+                }
+            ))
+        );
         Ok(())
     }
 

hugr/src/hugr/serialize/test.rs

@@ -419,13 +419,32 @@ fn polyfunctype1() -> PolyFuncType {
     PolyFuncType::new([TypeParam::max_nat(), TypeParam::Extensions], function_type)
 }
 
+fn polyfunctype2() -> PolyFuncType {
+    let tv0 = Type::new_row_var_use(0, TypeBound::Any);
+    let tv1 = Type::new_row_var_use(1, TypeBound::Eq);
+    let params = [TypeBound::Any, TypeBound::Eq].map(TypeParam::new_list);
+    let inputs = vec![
+        Type::new_function(FunctionType::new(tv0.clone(), tv1.clone())),
+        tv0,
+    ];
+    let res = PolyFuncType::new(params, FunctionType::new(inputs, tv1));
+    // Just check we've got the arguments the right way round
+    // (not that it really matters for the serialization schema we have)
+    res.validate_var_len(&EMPTY_REG).unwrap();
+    res
+}
+
 #[rstest]
 #[case(FunctionType::new_endo(type_row![]).into())]
 #[case(polyfunctype1())]
 #[case(PolyFuncType::new([TypeParam::Opaque { ty: int_custom_type(TypeArg::BoundedNat { n: 1 }) }], FunctionType::new_endo(type_row![Type::new_var_use(0, TypeBound::Copyable)])))]
 #[case(PolyFuncType::new([TypeBound::Eq.into()], FunctionType::new_endo(type_row![Type::new_var_use(0, TypeBound::Eq)])))]
-#[case(PolyFuncType::new([TypeParam::List { param: Box::new(TypeBound::Any.into()) }], FunctionType::new_endo(type_row![])))]
+#[case(PolyFuncType::new([TypeParam::new_list(TypeBound::Any)], FunctionType::new_endo(type_row![])))]
 #[case(PolyFuncType::new([TypeParam::Tuple { params: [TypeBound::Any.into(), TypeParam::bounded_nat(2.try_into().unwrap())].into() }], FunctionType::new_endo(type_row![])))]
+#[case(PolyFuncType::new(
+    [TypeParam::new_list(TypeBound::Any)],
+    FunctionType::new_endo(Type::new_tuple(Type::new_row_var_use(0, TypeBound::Any)))))]
+#[case(polyfunctype2())]
 fn roundtrip_polyfunctype(#[case] poly_func_type: PolyFuncType) {
     check_testing_roundtrip(poly_func_type)
 }

hugr/src/hugr/validate.rs

@@ -301,11 +301,14 @@ impl<'a, 'b> ValidationContext<'a, 'b> {
         var_decls: &[TypeParam],
     ) -> Result<(), SignatureError> {
         match &port_kind {
-            EdgeKind::Value(ty) => ty.validate(self.extension_registry, var_decls),
+            EdgeKind::Value(ty) => ty.validate(false, self.extension_registry, var_decls),
             // Static edges must *not* refer to type variables declared by enclosing FuncDefns
-            // as these are only types at runtime.
-            EdgeKind::Const(ty) => ty.validate(self.extension_registry, &[]),
-            EdgeKind::Function(pf) => pf.validate(self.extension_registry),
+            // as these are only types at runtime. (Note the choice of `allow_row_vars` as `false` is arbitrary here.)
+            EdgeKind::Const(ty) => ty.validate(false, self.extension_registry, &[]),
+            // Allow function "value" to have unknown arity. A Call node will have to provide
+            // TypeArgs that produce a known arity, but a LoadFunction might pass the function
+            // value ("function pointer") around without knowing how to call it.
+            EdgeKind::Function(pf) => pf.validate_var_len(self.extension_registry),
             _ => Ok(()),
         }
     }

hugr/src/hugr/validate/test.rs

@@ -1,4 +1,5 @@
 use cool_asserts::assert_matches;
+use rstest::rstest;
 
 use super::*;
 use crate::builder::test::closed_dfg_root_hugr;
@@ -10,7 +11,7 @@ use crate::extension::prelude::{BOOL_T, PRELUDE, PRELUDE_ID, USIZE_T};
 use crate::extension::{Extension, ExtensionSet, TypeDefBound, EMPTY_REG, PRELUDE_REGISTRY};
 use crate::hugr::hugrmut::sealed::HugrMutInternals;
 use crate::hugr::HugrMut;
-use crate::ops::dataflow::IOTrait;
+use crate::ops::dataflow::{IOTrait, LoadFunction};
 use crate::ops::handle::NodeHandle;
 use crate::ops::leaf::MakeTuple;
 use crate::ops::{self, Noop, OpType, Value};
@@ -546,6 +547,148 @@ fn no_polymorphic_consts() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
+fn extension_with_eval_parallel() -> Extension {
+    let rowp = TypeParam::new_list(TypeBound::Any);
+    let mut e = Extension::new(EXT_ID);
+
+    let inputs = Type::new_row_var_use(0, TypeBound::Any);
+    let outputs = Type::new_row_var_use(1, TypeBound::Any);
+    let evaled_fn = Type::new_function(FunctionType::new(inputs.clone(), outputs.clone()));
+    let pf = PolyFuncType::new(
+        [rowp.clone(), rowp.clone()],
+        FunctionType::new(vec![evaled_fn, inputs], outputs),
+    );
+    e.add_op("eval".into(), "".into(), pf).unwrap();
+
+    let rv = |idx| Type::new_row_var_use(idx, TypeBound::Any);
+    let pf = PolyFuncType::new(
+        [rowp.clone(), rowp.clone(), rowp.clone(), rowp.clone()],
+        FunctionType::new(
+            vec![
+                Type::new_function(FunctionType::new(rv(0), rv(2))),
+                Type::new_function(FunctionType::new(rv(1), rv(3))),
+            ],
+            Type::new_function(FunctionType::new(vec![rv(0), rv(1)], vec![rv(2), rv(3)])),
+        ),
+    );
+    e.add_op("parallel".into(), "".into(), pf).unwrap();
+
+    e
+}
+
+#[test]
+fn instantiate_row_variables() -> Result<(), Box<dyn std::error::Error>> {
+    fn uint_seq(i: usize) -> TypeArg {
+        vec![TypeArg::Type { ty: USIZE_T }; i].into()
+    }
+    let e = extension_with_eval_parallel();
+    let mut dfb = DFGBuilder::new(FunctionType::new(
+        vec![
+            Type::new_function(FunctionType::new(USIZE_T, vec![USIZE_T, USIZE_T])),
+            USIZE_T,
+        ], // inputs: function + its argument
+        vec![USIZE_T; 4], // outputs (*2^2, three calls)
+    ))?;
+    let [func, int] = dfb.input_wires_arr();
+    let eval = e.instantiate_extension_op("eval", [uint_seq(1), uint_seq(2)], &PRELUDE_REGISTRY)?;
+    let [a, b] = dfb.add_dataflow_op(eval, [func, int])?.outputs_arr();
+    let par = e.instantiate_extension_op(
+        "parallel",
+        [uint_seq(1), uint_seq(1), uint_seq(2), uint_seq(2)],
+        &PRELUDE_REGISTRY,
+    )?;
+    let [par_func] = dfb.add_dataflow_op(par, [func, func])?.outputs_arr();
+    let eval2 =
+        e.instantiate_extension_op("eval", [uint_seq(2), uint_seq(4)], &PRELUDE_REGISTRY)?;
+    let eval2 = dfb.add_dataflow_op(eval2, [par_func, a, b])?;
+    dfb.finish_hugr_with_outputs(
+        eval2.outputs(),
+        &ExtensionRegistry::try_new([PRELUDE.to_owned(), e]).unwrap(),
+    )?;
+    Ok(())
+}
+
+fn seq1ty(t: Type) -> TypeArg {
+    TypeArg::Sequence {
+        elems: vec![t.into()],
+    }
+}
+
+#[test]
+fn inner_row_variables() -> Result<(), Box<dyn std::error::Error>> {
+    let e = extension_with_eval_parallel();
+    let tv = Type::new_row_var_use(0, TypeBound::Any);
+    let inner_ft = Type::new_function(FunctionType::new_endo(tv.clone()));
+    let ft_usz = Type::new_function(FunctionType::new_endo(vec![tv.clone(), USIZE_T]));
+    let mut fb = FunctionBuilder::new(
+        "id",
+        PolyFuncType::new(
+            [TypeParam::new_list(TypeBound::Any)],
+            FunctionType::new(inner_ft.clone(), ft_usz),
+        ),
+    )?;
+    // All the wires here are carrying higher-order Function values
+    let [func_arg] = fb.input_wires_arr();
+    let [id_usz] = {
+        let bldr = fb.define_function("id_usz", FunctionType::new_endo(USIZE_T).into())?;
+        let vals = bldr.input_wires();
+        let [inner_def] = bldr.finish_with_outputs(vals)?.outputs_arr();
+        let loadf = LoadFunction::try_new(
+            FunctionType::new_endo(USIZE_T).into(),
+            [],
+            &PRELUDE_REGISTRY,
+        )
+        .unwrap();
+        fb.add_dataflow_op(loadf, [inner_def])?.outputs_arr()
+    };
+    let par = e.instantiate_extension_op(
+        "parallel",
+        [tv.clone(), USIZE_T, tv.clone(), USIZE_T].map(seq1ty),
+        &PRELUDE_REGISTRY,
+    )?;
+    let par_func = fb.add_dataflow_op(par, [func_arg, id_usz])?;
+    fb.finish_hugr_with_outputs(
+        par_func.outputs(),
+        &ExtensionRegistry::try_new([PRELUDE.to_owned(), e]).unwrap(),
+    )?;
+    Ok(())
+}
+
+#[rstest]
+#[case(false)]
+#[case(true)]
+fn no_outer_row_variables(#[case] connect: bool) -> Result<(), Box<dyn std::error::Error>> {
+    let e = extension_with_eval_parallel();
+    let tv = Type::new_row_var_use(0, TypeBound::Copyable);
+    let mut fb = FunctionBuilder::new(
+        "bad_eval",
+        PolyFuncType::new(
+            [TypeParam::new_list(TypeBound::Copyable)],
+            FunctionType::new(
+                Type::new_function(FunctionType::new(USIZE_T, tv.clone())),
+                if connect { vec![tv.clone()] } else { vec![] },
+            ),
+        ),
+    )?;
+    let [func_arg] = fb.input_wires_arr();
+    let i = fb.add_load_value(crate::extension::prelude::ConstUsize::new(5));
+    let ev =
+        e.instantiate_extension_op("eval", [seq1ty(USIZE_T), seq1ty(tv)], &PRELUDE_REGISTRY)?;
+    let ev = fb.add_dataflow_op(ev, [func_arg, i])?;
+    let reg = ExtensionRegistry::try_new([PRELUDE.to_owned(), e]).unwrap();
+    if connect {
+        fb.set_outputs(ev.outputs())?;
+    }
+    assert_eq!(
+        fb.finish_hugr(&reg).unwrap_err(),
+        ValidationError::SignatureError {
+            node: ev.node(),
+            cause: SignatureError::RowTypeVarOutsideRow { idx: 0 }
+        }
+    );
+    Ok(())
+}
+
 #[test]
 fn test_polymorphic_call() -> Result<(), Box<dyn std::error::Error>> {
     let mut e = Extension::new(EXT_ID);
@@ -562,7 +705,7 @@ fn test_polymorphic_call() -> Result<(), Box<dyn std::error::Error>> {
         )
         .with_extension_delta(ExtensionSet::type_var(1)),
     );
-    // The higher-order "eval" operation - takes a function and its argument.
+    // Single-input/output version of the higher-order "eval" operation, with extension param.
     // Note the extension-delta of the eval node includes that of the input function.
     e.add_op(
         "eval".into(),

hugr/src/ops/constant.rs

@@ -668,7 +668,7 @@ mod test {
                         32, // Target around 32 total elements
                         3,  // Each collection is up to 3 elements long
                         |element| {
-                            (any::<Type>(), vec(element.clone(), 0..3)).prop_map(
+                            (Type::any_non_row_var(), vec(element.clone(), 0..3)).prop_map(
                                 |(typ, contents)| {
                                     OpaqueValue::new(ListValue::new(
                                         typ,