feat!: replace opaque type arguments with String (#1328)

Closes #1308

BREAKING CHANGE: opaque type parameters replaced with string parameters.

hugr-core/src/extension/declarative.rs

@@ -313,13 +313,13 @@ extensions:
  - name: MyType
  description: A simple type with no parameters
  # Parametric types are not currently supported.
- params: [Any, ["An unbounded natural number", USize]]
+ params: [String]
  operations:
  - name: UnsupportedOperation
  description: An operation from 3 qubits to 3 qubits
  params:
  # Parametric operations are not currently supported.
- param1: USize
+  param1: String
  signature:
  # Type declarations will have their own syntax.
  inputs: []

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

@@ -9,7 +9,7 @@
 
 use crate::extension::{TypeDef, TypeDefBound};
 use crate::types::type_param::TypeParam;
-use crate::types::{CustomType, TypeBound, TypeName};
+use crate::types::{TypeBound, TypeName};
 use crate::Extension;
 
 use serde::{Deserialize, Serialize};
@@ -100,14 +100,13 @@ impl From<TypeDefBoundDeclaration> for TypeDefBound {
 
 /// A declarative type parameter definition.
 ///
-/// Either a type, or a 2-element list containing a human-readable name and a type id.
+/// Only supports [TypeParam::String]s for now.
 #[derive(Debug, Clone, Hash, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(untagged)]
 enum TypeParamDeclaration {
- /// Just the type id.
- Type(TypeName),
+ String,
  /// A 2-tuple containing a human-readable name and a type id.
- WithDescription(String, TypeName),
+ WithDescription(String),
 }
 
 impl TypeParamDeclaration {
@@ -119,52 +118,9 @@ impl TypeParamDeclaration {
  /// TODO: The parameter description is currently ignored.
  pub fn make_type_param(
  &self,
- extension: &Extension,
- ctx: DeclarationContext<'_>,
+ _extension: &Extension,
+ _ctx: DeclarationContext<'_>,
  ) -> Result<TypeParam, ExtensionDeclarationError> {
- let instantiate_type = |ty: &TypeDef| -> Result<CustomType, ExtensionDeclarationError> {
- match ty.params() {
- [] => Ok(ty.instantiate([]).unwrap()),
- _ => Err(ExtensionDeclarationError::ParametricTypeParameter {
- ext: extension.name().clone(),
- ty: self.type_name().clone(),
- }),
- }
- };
-
- // First try the previously defined types in the current extension.
- if let Some(ty) = extension.get_type(self.type_name()) {
- return Ok(TypeParam::Opaque {
- ty: instantiate_type(ty)?,
- });
- }
-
- // Try every extension in scope.
- //
- // TODO: Can we resolve the extension id from the type name instead?
- for ext in ctx.scope.iter() {
- if let Some(ty) = ctx
- .registry
- .get(ext)
- .and_then(|ext| ext.get_type(self.type_name()))
- {
- return Ok(TypeParam::Opaque {
- ty: instantiate_type(ty)?,
- });
- }
- }
-
- Err(ExtensionDeclarationError::MissingType {
- ext: extension.name().clone(),
- ty: self.type_name().clone(),
- })
- }
-
- /// Returns the type name of this type parameter.
- fn type_name(&self) -> &TypeName {
- match self {
- Self::Type(ty) => ty,
- Self::WithDescription(_, ty) => ty,
- }
+ Ok(TypeParam::String)
  }
 }

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

@@ -11,7 +11,7 @@ use crate::ops::custom::{ExtensionOp, OpaqueOp};
 use crate::ops::{self, dataflow::IOTrait, Input, Module, Noop, Output, Value, DFG};
 use crate::std_extensions::arithmetic::float_types::FLOAT64_TYPE;
 use crate::std_extensions::arithmetic::int_ops::INT_OPS_REGISTRY;
-use crate::std_extensions::arithmetic::int_types::{int_custom_type, ConstInt, INT_TYPES};
+use crate::std_extensions::arithmetic::int_types::{ConstInt, INT_TYPES};
 use crate::std_extensions::logic::NotOp;
 use crate::types::type_param::TypeParam;
 use crate::types::{
@@ -473,7 +473,7 @@ fn polyfunctype2() -> PolyFuncTypeRV {
 #[rstest]
 #[case(Signature::new_endo(type_row![]).into())]
 #[case(polyfunctype1())]
-#[case(PolyFuncType::new([TypeParam::Opaque { ty: int_custom_type(TypeArg::BoundedNat { n: 1 }) }], Signature::new_endo(type_row![Type::new_var_use(0, TypeBound::Copyable)])))]
+#[case(PolyFuncType::new([TypeParam::String], Signature::new_endo(type_row![Type::new_var_use(0, TypeBound::Copyable)])))]
 #[case(PolyFuncType::new([TypeBound::Eq.into()], Signature::new_endo(type_row![Type::new_var_use(0, TypeBound::Eq)])))]
 #[case(PolyFuncType::new([TypeParam::new_list(TypeBound::Any)], Signature::new_endo(type_row![])))]
 #[case(PolyFuncType::new([TypeParam::Tuple { params: [TypeBound::Any.into(), TypeParam::bounded_nat(2.try_into().unwrap())].into() }], Signature::new_endo(type_row![])))]
@@ -486,7 +486,7 @@ fn roundtrip_polyfunctype_fixedlen(#[case] poly_func_type: PolyFuncType) {
 
 #[rstest]
 #[case(FuncValueType::new_endo(type_row![]).into())]
-#[case(PolyFuncTypeRV::new([TypeParam::Opaque { ty: int_custom_type(TypeArg::BoundedNat { n: 1 }) }], FuncValueType::new_endo(type_row![Type::new_var_use(0, TypeBound::Copyable)])))]
+#[case(PolyFuncTypeRV::new([TypeParam::String], FuncValueType::new_endo(type_row![Type::new_var_use(0, TypeBound::Copyable)])))]
 #[case(PolyFuncTypeRV::new([TypeBound::Eq.into()], FuncValueType::new_endo(type_row![Type::new_var_use(0, TypeBound::Eq)])))]
 #[case(PolyFuncTypeRV::new([TypeParam::new_list(TypeBound::Any)], FuncValueType::new_endo(type_row![])))]
 #[case(PolyFuncTypeRV::new([TypeParam::Tuple { params: [TypeBound::Any.into(), TypeParam::bounded_nat(2.try_into().unwrap())].into() }], FuncValueType::new_endo(type_row![])))]

hugr-core/src/types/poly_func.rs

@@ -146,7 +146,7 @@ pub(crate) mod test {
  use cool_asserts::assert_matches;
  use lazy_static::lazy_static;
 
- use crate::extension::prelude::{BOOL_T, PRELUDE_ID, USIZE_CUSTOM_T, USIZE_T};
+ use crate::extension::prelude::{BOOL_T, PRELUDE_ID, USIZE_T};
  use crate::extension::{
  ExtensionId, ExtensionRegistry, SignatureError, TypeDefBound, EMPTY_REG, PRELUDE,
  PRELUDE_REGISTRY,
@@ -277,7 +277,7 @@ pub(crate) mod test {
  TypeParam::List {
  param: Box::new(TypeParam::max_nat()),
  },
- TypeParam::Opaque { ty: USIZE_CUSTOM_T },
+ TypeParam::String,
  TypeParam::Tuple {
  params: vec![TypeBound::Any.into(), TypeParam::max_nat()],
  },

hugr-core/src/types/type_param.rs

@@ -10,13 +10,12 @@ use proptest_derive::Arbitrary;
 use std::num::NonZeroU64;
 use thiserror::Error;
 
+use super::row_var::MaybeRV;
+use super::{check_typevar_decl, RowVariable, Substitution, Type, TypeBase, TypeBound};
 use crate::extension::ExtensionRegistry;
 use crate::extension::ExtensionSet;
 use crate::extension::SignatureError;
 
-use super::row_var::MaybeRV;
-use super::{check_typevar_decl, CustomType, RowVariable, Substitution, Type, TypeBase, TypeBound};
-
 /// The upper non-inclusive bound of a [`TypeParam::BoundedNat`]
 // A None inner value implies the maximum bound: u64::MAX + 1 (all u64 values valid)
 #[derive(
@@ -68,11 +67,8 @@ pub enum TypeParam {
  /// Upper bound for the Nat parameter.
  bound: UpperBound,
  },
- /// Argument is a [TypeArg::Opaque], defined by a [CustomType].
- Opaque {
- /// The [CustomType] defining the parameter.
- ty: CustomType,
- },
+ /// Argument is a [TypeArg::String].
+ String,
  /// Argument is a [TypeArg::Sequence]. A list of indeterminate size containing
  /// parameters all of the (same) specified element type.
  List {
@@ -119,7 +115,7 @@ impl TypeParam {
  (TypeParam::BoundedNat { bound: b1 }, TypeParam::BoundedNat { bound: b2 }) => {
  b1.contains(b2)
  }
- (TypeParam::Opaque { ty: c1 }, TypeParam::Opaque { ty: c2 }) => c1 == c2,
+ (TypeParam::String, TypeParam::String) => true,
  (TypeParam::List { param: e1 }, TypeParam::List { param: e2 }) => e1.contains(e2),
  (TypeParam::Tuple { params: es1 }, TypeParam::Tuple { params: es2 }) => {
  es1.len() == es2.len() && es1.iter().zip(es2).all(|(e1, e2)| e1.contains(e2))
@@ -157,11 +153,10 @@ pub enum TypeArg {
  #[allow(missing_docs)]
  n: u64,
  },
- ///Instance of [TypeParam::Opaque] An opaque value, stored as serialized blob.
- Opaque {
+ ///Instance of [TypeParam::String]. UTF-8 encoded string argument.
+ String {
  #[allow(missing_docs)]
- #[serde(flatten)]
- arg: CustomTypeArg,
+ arg: String,
  },
  /// Instance of [TypeParam::List] or [TypeParam::Tuple], defined by a
  /// sequence of elements.
@@ -199,9 +194,9 @@ impl From<u64> for TypeArg {
  }
 }
 
-impl From<CustomTypeArg> for TypeArg {
- fn from(arg: CustomTypeArg) -> Self {
- Self::Opaque { arg }
+impl From<String> for TypeArg {
+ fn from(arg: String) -> Self {
+ TypeArg::String { arg }
  }
 }
 
@@ -261,14 +256,7 @@ impl TypeArg {
  ) -> Result<(), SignatureError> {
  match self {
  TypeArg::Type { ty } => ty.validate(extension_registry, var_decls),
- TypeArg::BoundedNat { .. } => Ok(()),
- TypeArg::Opaque { arg: custarg } => {
- // We could also add a facility to Extension to validate that the constant *value*
- // here is a valid instance of the type.
- // The type must be equal to that declared (in a TypeParam) by the instantiated TypeDef,
- // so cannot contain variables declared by the instantiator (providing the TypeArgs)
- custarg.typ.validate(extension_registry, &[])
- }
+ TypeArg::BoundedNat { .. } | TypeArg::String { .. } => Ok(()),
  TypeArg::Sequence { elems } => elems
  .iter()
  .try_for_each(|a| a.validate(extension_registry, var_decls)),
@@ -293,15 +281,7 @@ impl TypeArg {
  // RowVariables are represented as TypeArg::Variable
  ty.substitute1(t).into()
  }
- TypeArg::BoundedNat { .. } => self.clone(), // We do not allow variables as bounds on BoundedNat's
- TypeArg::Opaque {
- arg: CustomTypeArg { typ, .. },
- } => {
- // The type must be equal to that declared (in a TypeParam) by the instantiated TypeDef,
- // so cannot contain variables declared by the instantiator (providing the TypeArgs)
- debug_assert_eq!(&typ.substitute(t), typ);
- self.clone()
- }
+ TypeArg::BoundedNat { .. } | TypeArg::String { .. } => self.clone(), // We do not allow variables as bounds on BoundedNat's
  TypeArg::Sequence { elems } => {
  let mut are_types = elems.iter().map(|ta| match ta {
  TypeArg::Type { .. } => true,
@@ -356,29 +336,6 @@ impl TypeArgVariable {
  }
 }
 
-/// A serialized representation of a value of a [CustomType]
-/// restricted to equatable types.
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-pub struct CustomTypeArg {
- /// The type of the constant.
- /// (Exact matches only - the constant is exactly this type.)
- pub typ: CustomType,
- /// Serialized representation.
- pub value: serde_yaml::Value,
-}
-
-impl CustomTypeArg {
- /// Create a new CustomTypeArg. Enforces that the type must be checkable for
- /// equality.
- pub fn new(typ: CustomType, value: serde_yaml::Value) -> Result<Self, &'static str> {
- if typ.bound() == TypeBound::Eq {
- Ok(Self { typ, value })
- } else {
- Err("Only TypeBound::Eq CustomTypes can be used as TypeArgs")
- }
- }
-}
-
 /// Checks a [TypeArg] is as expected for a [TypeParam]
 pub fn check_type_arg(arg: &TypeArg, param: &TypeParam) -> Result<(), TypeArgError> {
  match (arg, param) {
@@ -424,11 +381,7 @@ pub fn check_type_arg(arg: &TypeArg, param: &TypeParam) -> Result<(), TypeArgErr
  Ok(())
  }
 
- (TypeArg::Opaque { arg }, TypeParam::Opaque { ty: param })
- if param.bound() == TypeBound::Eq && &arg.typ == param =>
- {
- Ok(())
- }
+ (TypeArg::String { .. }, TypeParam::String) => Ok(()),
  (TypeArg::Extensions { .. }, TypeParam::Extensions) => Ok(()),
  _ => Err(TypeArgError::TypeMismatch {
  arg: arg.clone(),
@@ -639,25 +592,10 @@ mod test {
 
  use proptest::prelude::*;
 
- use super::super::{CustomTypeArg, TypeArg, TypeArgVariable, TypeParam, UpperBound};
+ use super::super::{TypeArg, TypeArgVariable, TypeParam, UpperBound};
  use crate::extension::ExtensionSet;
- use crate::proptest::{any_serde_yaml_value, RecursionDepth};
- use crate::types::{CustomType, Type, TypeBound};
-
- impl Arbitrary for CustomTypeArg {
- type Parameters = RecursionDepth;
- type Strategy = BoxedStrategy<Self>;
- fn arbitrary_with(depth: Self::Parameters) -> Self::Strategy {
- (
- any_with::<CustomType>(
- <CustomType as Arbitrary>::Parameters::new(depth).with_bound(TypeBound::Eq),
- ),
- any_serde_yaml_value(),
- )
- .prop_map(|(ct, value)| CustomTypeArg::new(ct, value.clone()).unwrap())
- .boxed()
- }
- }
+ use crate::proptest::RecursionDepth;
+ use crate::types::{Type, TypeBound};
 
  impl Arbitrary for TypeArgVariable {
  type Parameters = RecursionDepth;
@@ -677,13 +615,11 @@ mod test {
  use prop::strategy::Union;
  let mut strat = Union::new([
  Just(Self::Extensions).boxed(),
+ Just(Self::String).boxed(),
  any::<TypeBound>().prop_map(|b| Self::Type { b }).boxed(),
  any::<UpperBound>()
  .prop_map(|bound| Self::BoundedNat { bound })
  .boxed(),
- any_with::<CustomType>(depth.into())
- .prop_map(|ty| Self::Opaque { ty })
- .boxed(),
  ]);
  if !depth.leaf() {
  // we descend here because we these constructors contain TypeParams
@@ -708,15 +644,13 @@ mod test {
  use prop::strategy::Union;
  let mut strat = Union::new([
  any::<u64>().prop_map(|n| Self::BoundedNat { n }).boxed(),
+ any::<String>().prop_map(|arg| Self::String { arg }).boxed(),
  any::<ExtensionSet>()
  .prop_map(|es| Self::Extensions { es })
  .boxed(),
  any_with::<Type>(depth)
  .prop_map(|ty| Self::Type { ty })
  .boxed(),
- any_with::<CustomTypeArg>(depth)
- .prop_map(|arg| Self::Opaque { arg })
- .boxed(),
  // TODO this is a bit dodgy, TypeArgVariables are supposed
  // to be constructed from TypeArg::new_var_use. We are only
  // using this instance for serialization now, but if we want