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

hugr/src/builder/build_traits.rs

@@ -19,7 +19,7 @@ use crate::{
     types::EdgeKind,
 };
 
-use crate::extension::{ExtensionRegistry, ExtensionSet, PRELUDE_REGISTRY};
+use crate::extension::{ExtensionRegistry, ExtensionSet, SignatureError, PRELUDE_REGISTRY};
 use crate::types::{FunctionType, PolyFuncType, Type, TypeArg, TypeRow};
 
 use itertools::Itertools;
@@ -645,6 +645,15 @@ fn add_node_with_wires<T: Dataflow + ?Sized>(
     inputs: impl IntoIterator<Item = Wire>,
 ) -> Result<(Node, usize), BuildError> {
     let nodetype: NodeType = nodetype.into();
+    // Check there are no row variables, as that would prevent us
+    // from indexing into the node's ports in order to wire up
+    nodetype
+        .op_signature()
+        .as_ref()
+        .and_then(FunctionType::find_rowvar)
+        .map_or(Ok(()), |(idx, _)| {
+            Err(SignatureError::RowVarWhereTypeExpected { idx })
+        })?;
     let num_outputs = nodetype.op().value_output_count();
     let op_node = data_builder.add_child_node(nodetype.clone());
 

hugr/src/hugr/validate.rs

@@ -20,7 +20,7 @@ use crate::ops::custom::{resolve_opaque_op, CustomOp};
 use crate::ops::validate::{ChildrenEdgeData, ChildrenValidationError, EdgeValidationError};
 use crate::ops::{FuncDefn, OpTag, OpTrait, OpType, ValidateOp};
 use crate::types::type_param::TypeParam;
-use crate::types::EdgeKind;
+use crate::types::{EdgeKind, FunctionType};
 use crate::{Direction, Hugr, Node, Port};
 
 use super::views::{HierarchyView, HugrView, SiblingGraph};
@@ -211,7 +211,20 @@ impl<'a, 'b> ValidationContext<'a, 'b> {
             }
         }
 
-        // Secondly that the node has correct children
+        // Secondly, check that the node signature does not contain any row variables.
+        // (We do this here so it's before we try indexing into the ports of any nodes).
+        op_type
+            .dataflow_signature()
+            .as_ref()
+            .and_then(FunctionType::find_rowvar)
+            .map_or(Ok(()), |(idx, _)| {
+                Err(ValidationError::SignatureError {
+                    node,
+                    cause: SignatureError::RowVarWhereTypeExpected { idx },
+                })
+            })?;
+
+        // Thirdly that the node has correct children
         self.validate_children(node, node_type)?;
 
         Ok(())

hugr/src/types/signature.rs

@@ -5,7 +5,7 @@ use itertools::Either;
 use std::fmt::{self, Display, Write};
 
 use super::type_param::TypeParam;
-use super::{Substitution, Type, TypeRow};
+use super::{Substitution, Type, TypeBound, TypeEnum, TypeRow};
 
 use crate::core::PortIndex;
 use crate::extension::{ExtensionRegistry, ExtensionSet, SignatureError};
@@ -98,31 +98,31 @@ impl FunctionType {
     /// of bounds.
     #[inline]
     pub fn in_port_type(&self, port: impl Into<IncomingPort>) -> Option<&Type> {
-        check_no_rowvars(&self.input);
+        debug_assert!(self.find_rowvar().is_none());
         self.input.get(port.into().index())
     }
 
     /// Returns the type of a value output [`Port`]. Returns `None` if the port is out
     /// of bounds.
     #[inline]
     pub fn out_port_type(&self, port: impl Into<OutgoingPort>) -> Option<&Type> {
-        check_no_rowvars(&self.output);
+        debug_assert!(self.find_rowvar().is_none());
         self.output.get(port.into().index())
     }
 
     /// Returns a mutable reference to the type of a value input [`Port`]. Returns `None` if the port is out
     /// of bounds.
     #[inline]
     pub fn in_port_type_mut(&mut self, port: impl Into<IncomingPort>) -> Option<&mut Type> {
-        check_no_rowvars(&self.input);
+        debug_assert!(self.find_rowvar().is_none());
         self.input.get_mut(port.into().index())
     }
 
     /// Returns the type of a value output [`Port`]. Returns `None` if the port is out
     /// of bounds.
     #[inline]
     pub fn out_port_type_mut(&mut self, port: impl Into<OutgoingPort>) -> Option<&mut Type> {
-        check_no_rowvars(&self.output);
+        debug_assert!(self.find_rowvar().is_none());
         self.output.get_mut(port.into().index())
     }
 
@@ -193,6 +193,17 @@ impl FunctionType {
 }
 
 impl FunctionType {
+    /// If this FunctionType contains any row variables, return one.
+    pub fn find_rowvar(&self) -> Option<(usize, TypeBound)> {
+        self.input
+            .iter()
+            .chain(self.output.iter())
+            .find_map(|t| match t.0 {
+                TypeEnum::RowVariable(idx, bound) => Some((idx, bound)),
+                _ => None,
+            })
+    }
+
     /// Returns the `Port`s in the signature for a given direction.
     #[inline]
     pub fn ports(&self, dir: Direction) -> impl Iterator<Item = Port> {
@@ -214,14 +225,6 @@ impl FunctionType {
     }
 }
 
-fn check_no_rowvars(row: &TypeRow) {
-    // debug_assert as feared too expensive to do at every runtime.
-    // TODO: consider caching the result (invalidate the cache on every get_mut),
-    // or statically rule out the various "port" methods for FunctionTypes
-    // that are not node signatures.
-    debug_assert!(!row.iter().any(Type::is_row_var));
-}
-
 impl Display for FunctionType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if !self.input.is_empty() {