refactor!: Flatten PrimType/PrimValue in to parent enum

src/types.rs

@@ -3,7 +3,6 @@
 mod check;
 pub mod custom;
 mod poly_func;
-mod primitive;
 mod serialize;
 mod signature;
 pub mod type_param;
@@ -26,7 +25,6 @@ use crate::ops::AliasDecl;
 use crate::type_row;
 use std::fmt::Debug;
 
-pub use self::primitive::PrimType;
 use self::type_param::TypeParam;
 
 #[cfg(feature = "pyo3")]
@@ -153,10 +151,22 @@ impl From<SumType> for Type {
 }
 
 #[derive(Clone, PartialEq, Debug, Eq, derive_more::Display)]
-/// Core types: primitive (leaf), tuple (product) or sum (co-product).
+/// Core types
 pub enum TypeEnum {
+ // TODO optimise with Box<CustomType> ?
+ // or some static version of this?
  #[allow(missing_docs)]
- Prim(PrimType),
+ Extension(CustomType),
+ #[allow(missing_docs)]
+ #[display(fmt = "Alias({})", "_0.name()")]
+ Alias(AliasDecl),
+ #[allow(missing_docs)]
+ #[display(fmt = "Function({})", "_0")]
+ Function(Box<PolyFuncType>),
+ // DeBruijn index, and cache of TypeBound (checked in validation)
+ #[allow(missing_docs)]
+ #[display(fmt = "Variable({})", _0)]
+ Variable(usize, TypeBound),
  #[allow(missing_docs)]
  #[display(fmt = "Tuple({})", "_0")]
  Tuple(TypeRow),
@@ -168,7 +178,10 @@ impl TypeEnum {
  /// The smallest type bound that covers the whole type.
  fn least_upper_bound(&self) -> TypeBound {
  match self {
- TypeEnum::Prim(p) => p.bound(),
+ TypeEnum::Extension(c) => c.bound(),
+ TypeEnum::Alias(a) => a.bound,
+ TypeEnum::Function(_) => TypeBound::Copyable,
+ TypeEnum::Variable(_, b) => *b,
  TypeEnum::Sum(SumType::Unit { size: _ }) => TypeBound::Eq,
  TypeEnum::Sum(SumType::General { row }) => {
  least_upper_bound(row.iter().map(Type::least_upper_bound))
@@ -216,7 +229,7 @@ impl Type {
 
  /// Initialize a new function type.
  pub fn new_function(fun_ty: impl Into<PolyFuncType>) -> Self {
- Self::new(TypeEnum::Prim(PrimType::Function(Box::new(fun_ty.into()))))
+ Self::new(TypeEnum::Function(Box::new(fun_ty.into())))
  }
 
  /// Initialize a new tuple type by providing the elements.
@@ -235,12 +248,12 @@ impl Type {
  // TODO remove? Extensions/TypeDefs should just provide `Type` directly
  pub const fn new_extension(opaque: CustomType) -> Self {
  let bound = opaque.bound();
- Type(TypeEnum::Prim(PrimType::Extension(opaque)), bound)
+ Type(TypeEnum::Extension(opaque), bound)
  }
 
  /// Initialize a new alias.
  pub fn new_alias(alias: AliasDecl) -> Self {
- Self::new(TypeEnum::Prim(PrimType::Alias(alias)))
+ Self::new(TypeEnum::Alias(alias))
  }
 
  fn new(type_e: TypeEnum) -> Self {
@@ -267,7 +280,7 @@ impl Type {
  /// 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 {
- Self(TypeEnum::Prim(PrimType::Variable(idx, bound)), bound)
+ Self(TypeEnum::Variable(idx, bound), bound)
  }
 
  /// Report the least upper TypeBound, if there is one.
@@ -307,25 +320,21 @@ impl Type {
  .iter()
  .try_for_each(|t| t.validate(extension_registry, var_decls)),
  TypeEnum::Sum(SumType::Unit { .. }) => Ok(()), // No leaves there
- TypeEnum::Prim(PrimType::Alias(_)) => Ok(()),
- TypeEnum::Prim(PrimType::Extension(custy)) => {
- custy.validate(extension_registry, var_decls)
- }
- TypeEnum::Prim(PrimType::Function(ft)) => ft.validate(extension_registry, var_decls),
- TypeEnum::Prim(PrimType::Variable(idx, bound)) => {
+ 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, &TypeParam::Type(*bound))
  }
  }
  }
 
  pub(crate) fn substitute(&self, t: &impl Substitution) -> Self {
  match &self.0 {
- TypeEnum::Prim(PrimType::Alias(_)) | TypeEnum::Sum(SumType::Unit { .. }) => {
- self.clone()
- }
- TypeEnum::Prim(PrimType::Variable(idx, bound)) => t.apply_typevar(*idx, *bound),
- TypeEnum::Prim(PrimType::Extension(cty)) => Type::new_extension(cty.substitute(t)),
- TypeEnum::Prim(PrimType::Function(bf)) => Type::new_function(bf.substitute(t)),
+ TypeEnum::Alias(_) | TypeEnum::Sum(SumType::Unit { .. }) => self.clone(),
+ TypeEnum::Variable(idx, bound) => t.apply_typevar(*idx, *bound),
+ 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)),
  }

src/types/check.rs

@@ -1,12 +1,9 @@
 //! Logic for checking values against types.
 use thiserror::Error;
 
-use crate::{
- values::{PrimValue, Value},
- HugrView,
-};
+use crate::{values::Value, HugrView};
 
-use super::{primitive::PrimType, CustomType, Type, TypeEnum};
+use super::{CustomType, Type, TypeEnum};
 
 /// Struct for custom type check fails.
 #[derive(Clone, Debug, PartialEq, Eq, Error)]
@@ -48,46 +45,25 @@ pub enum ConstTypeError {
  CustomCheckFail(#[from] CustomCheckFailure),
 }
 
-impl PrimType {
- /// Check that a [`PrimValue`] is a valid instance of this [`PrimType`].
+impl Type {
+ /// Check that a [`Value`] is a valid instance of this [`Type`].
  ///
  /// # Errors
  ///
  /// This function will return an error if there is a type check error.
- pub fn check_type(&self, val: &PrimValue) -> Result<(), ConstTypeError> {
- if let PrimType::Alias(alias) = self {
- return Err(ConstTypeError::NoAliases(alias.name().to_string()));
- }
-
- match (self, val) {
- (PrimType::Extension(e), PrimValue::Extension { c: e_val }) => {
+ pub fn check_type(&self, val: &Value) -> Result<(), ConstTypeError> {
+ match (&self.0, val) {
+ (TypeEnum::Extension(e), Value::Extension { c: e_val }) => {
  e_val.0.check_custom_type(e)?;
  Ok(())
  }
- (PrimType::Function(t), PrimValue::Function { hugr: v })
+ (TypeEnum::Function(t), Value::Function { hugr: v })
  if v.get_function_type().is_some_and(|f| &**t == f) =>
  {
  // exact signature equality, in future this may need to be
  // relaxed to be compatibility checks between the signatures.
  Ok(())
  }
- _ => Err(ConstTypeError::ValueCheckFail(
- Type::new(TypeEnum::Prim(self.clone())),
- Value::Prim { val: val.clone() },
- )),
- }
- }
-}
-
-impl Type {
- /// Check that a [`Value`] is a valid instance of this [`Type`].
- ///
- /// # Errors
- ///
- /// This function will return an error if there is a type check error.
- pub fn check_type(&self, val: &Value) -> Result<(), ConstTypeError> {
- match (&self.0, val) {
- (TypeEnum::Prim(p), Value::Prim { val: p_v }) => p.check_type(p_v),
  (TypeEnum::Tuple(t), Value::Tuple { vs: t_v }) => {
  if t.len() != t_v.len() {
  return Err(ConstTypeError::TupleWrongLength);

src/types/poly_func.rs

@@ -12,7 +12,7 @@ use super::{FunctionType, Substitution};
 /// A polymorphic function type, e.g. of a [Graph], or perhaps an [OpDef].
 /// (Nodes/operations in the Hugr are not polymorphic.)
 ///
-/// [Graph]: crate::values::PrimValue::Function
+/// [Graph]: crate::values::Value::Function
 /// [OpDef]: crate::extension::OpDef
 #[derive(
  Clone, PartialEq, Debug, Eq, derive_more::Display, serde::Serialize, serde::Deserialize,

src/types/serialize.rs

@@ -4,7 +4,6 @@ use super::custom::CustomType;
 
 use crate::extension::prelude::{array_type, QB_T, USIZE_T};
 use crate::ops::AliasDecl;
-use crate::types::primitive::PrimType;
 
 #[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
 #[serde(tag = "t")]
@@ -31,12 +30,10 @@ impl From<Type> for SerSimpleType {
  // TODO short circuiting for array.
  let Type(value, _) = value;
  match value {
- TypeEnum::Prim(t) => match t {
- PrimType::Extension(c) => SerSimpleType::Opaque(c),
- PrimType::Alias(a) => SerSimpleType::Alias(a),
- PrimType::Function(sig) => SerSimpleType::G(sig),
- PrimType::Variable(i, b) => SerSimpleType::V { i, b },
- },
+ TypeEnum::Extension(c) => SerSimpleType::Opaque(c),
+ TypeEnum::Alias(a) => SerSimpleType::Alias(a),
+ TypeEnum::Function(sig) => SerSimpleType::G(sig),
+ TypeEnum::Variable(i, b) => SerSimpleType::V { i, b },
  TypeEnum::Sum(sum) => SerSimpleType::Sum(sum),
  TypeEnum::Tuple(inner) => SerSimpleType::Tuple { inner },
  }

src/values.rs

@@ -13,10 +13,11 @@ use crate::{Hugr, HugrView};
 
 use crate::types::{CustomCheckFailure, CustomType};
 
-/// A constant value of a primitive (or leaf) type.
+/// A value that can be stored as a static constant. Representing core types and
+/// extension types.
 #[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
-#[serde(tag = "pv")]
-pub enum PrimValue {
+#[serde(tag = "v")]
+pub enum Value {
  /// An extension constant value, that can check it is of a given [CustomType].
  ///
  // Note: the extra level of tupling is to avoid https://github.com/rust-lang/rust/issues/78808
@@ -30,32 +31,6 @@ pub enum PrimValue {
  #[allow(missing_docs)]
  hugr: Box<Hugr>,
  },
-}
-
-impl PrimValue {
- fn name(&self) -> String {
- match self {
- PrimValue::Extension { c: e } => format!("const:custom:{}", e.0.name()),
- PrimValue::Function { hugr: h } => {
- let Some(t) = h.get_function_type() else {
- panic!("HUGR root node isn't a valid function parent.");
- };
- format!("const:function:[{}]", t)
- }
- }
- }
-}
-
-/// A value that can be stored as a static constant. Representing core types and
-/// extension types.
-#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
-#[serde(tag = "v")]
-pub enum Value {
- /// A primitive (non-container) value.
- Prim {
- #[allow(missing_docs)]
- val: PrimValue,
- },
  /// A tuple
  Tuple {
  #[allow(missing_docs)]
@@ -75,7 +50,13 @@ impl Value {
  /// Returns the name of this [`Value`].
  pub fn name(&self) -> String {
  match self {
- Value::Prim { val: p } => p.name(),
+ Value::Extension { c: e } => format!("const:custom:{}", e.0.name()),
+ Value::Function { hugr: h } => {
+ let Some(t) = h.get_function_type() else {
+ panic!("HUGR root node isn't a valid function parent.");
+ };
+ format!("const:function:[{}]", t)
+ }
  Value::Tuple { vs: vals } => {
  let names: Vec<_> = vals.iter().map(Value::name).collect();
  format!("const:seq:{{{}}}", names.join(", "))
@@ -123,17 +104,12 @@ impl Value {
 
  /// New custom value (of type that implements [`CustomConst`]).
  pub fn custom<C: CustomConst>(c: C) -> Self {
- Self::Prim {
- val: PrimValue::Extension { c: (Box::new(c),) },
- }
+ Self::Extension { c: (Box::new(c),) }
  }
 
  /// For a Const holding a CustomConst, extract the CustomConst by downcasting.
  pub fn get_custom_value<T: CustomConst>(&self) -> Option<&T> {
- if let Value::Prim {
- val: PrimValue::Extension { c: (custom,) },
- } = self
- {
+ if let Value::Extension { c: (custom,) } = self {
  custom.downcast_ref()
  } else {
  None
@@ -286,10 +262,8 @@ pub(crate) mod test {
 
  #[rstest]
  fn function_value(simple_dfg_hugr: Hugr) {
- let v = Value::Prim {
- val: PrimValue::Function {
- hugr: Box::new(simple_dfg_hugr),
- },
+ let v = Value::Function {
+ hugr: Box::new(simple_dfg_hugr),
  };
 
  let correct_type = Type::new_function(FunctionType::new_linear(type_row![