Enable TypeDef reporting of type tag.

Closes #286

src/extensions/rotation.rs

@@ -75,6 +75,7 @@ impl Type {
             params: vec![],
             description: self.description().to_string(),
             resource: None,
+            tag: crate::types::TypeTag::Classic.into(),
         }
     }
 }

src/resource.rs

@@ -12,6 +12,7 @@ use smol_str::SmolStr;
 use thiserror::Error;
 
 use crate::types::type_param::{check_type_arg, TypeArgError};
+use crate::types::TypeTag;
 use crate::types::{
     type_param::{TypeArg, TypeParam},
     Signature, SignatureDescription, SimpleRow,
@@ -288,6 +289,20 @@ impl OpDef {
     }
 }
 
+/// The type tag of a [`TypeDef`]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+pub enum TypeDefTag {
+    /// Defined by an explicit tag.
+    Explicit(TypeTag),
+    /// Derived as the tag containing all marked type parameters.
+    FromParams(Vec<usize>),
+}
+
+impl From<TypeTag> for TypeDefTag {
+    fn from(tag: TypeTag) -> Self {
+        Self::Explicit(tag)
+    }
+}
 /// A declaration of an opaque type.
 /// Note this does not provide any way to create instances
 /// - typically these are operations also provided by the Resource.
@@ -304,6 +319,32 @@ pub struct TypeDef {
     pub resource: Option<ResourceId>,
     /// Human readable description of the type definition.
     pub description: String,
+    /// The definition of the type tag of this definition.
+    pub tag: TypeDefTag,
+}
+
+impl TypeDef {
+    /// The [`TypeTag`] of the definition.
+    pub fn tag(&self, args: &[TypeArg]) -> TypeTag {
+        match &self.tag {
+            TypeDefTag::Explicit(tag) => *tag,
+            TypeDefTag::FromParams(indices) => {
+                let args: Vec<_> = args.iter().collect();
+                if indices.is_empty() {
+                    // Assume most general case
+                    return TypeTag::Simple;
+                }
+                indices
+                    .iter()
+                    .map(|i| {
+                        args.get(*i)
+                            .and_then(|ta| ta.tag())
+                            .expect("TypeParam index invalid or param does not have a TypeTag.")
+                    })
+                    .fold(TypeTag::Hashable, TypeTag::union)
+            }
+        }
+    }
 }
 
 /// A unique identifier for a resource.

src/types/simple.rs

@@ -62,7 +62,7 @@ pub enum TypeTag {
 impl TypeTag {
     /// Returns the smallest TypeTag containing both the receiver and argument.
     /// (This will be one of the receiver or the argument.)
-    fn union(self, other: Self) -> Self {
+    pub fn union(self, other: Self) -> Self {
         if self == Self::Simple || other == Self::Simple {
             Self::Simple
         } else if self == Self::Classic || other == Self::Classic {

src/types/type_param.rs

@@ -8,7 +8,7 @@ use thiserror::Error;
 
 use crate::ops::constant::HugrIntValueStore;
 
-use super::{ClassicType, SimpleType};
+use super::{ClassicType, PrimType, SimpleType, TypeTag};
 
 /// A parameter declared by an OpDef. Specifies a value
 /// that must be provided by each operation node.
@@ -51,6 +51,19 @@ pub enum TypeArg {
     Value(serde_yaml::Value),
 }
 
+impl TypeArg {
+    /// Report [`TypeArg`] if param is a type
+    pub fn tag(&self) -> Option<TypeTag> {
+        match self {
+            TypeArg::Type(s) => Some(s.tag()),
+            TypeArg::ClassicType(c) => Some(c.tag()),
+            // assume list is well formed - all elements of same type
+            TypeArg::List(t) => t.iter().next().and_then(TypeArg::tag),
+            _ => None,
+        }
+    }
+}
+
 /// Checks a [TypeArg] is as expected for a [TypeParam]
 pub fn check_type_arg(arg: &TypeArg, param: &TypeParam) -> Result<(), TypeArgError> {
     match (arg, param) {