Type of constants in core Terms.

Author: zrho

hugr-core/src/export.rs

@@ -996,6 +996,10 @@ impl<'a> Context<'a> {
             }
             Term::Variable(v) => self.export_type_arg_var(v),
             Term::StaticType => self.make_term_apply(model::CORE_STATIC, &[]),
+            Term::Const(ty) => {
+                let ty = self.export_type(ty);
+                self.make_term_apply(model::CORE_CONST, &[ty])
+            }
         }
     }
 

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

@@ -217,6 +217,7 @@ pub(super) fn collect_term_exts(
 ) {
     match term {
         Term::Runtime(ty) => collect_type_exts(ty, used_extensions, missing_extensions),
+        Term::Const(ty) => collect_type_exts(ty, used_extensions, missing_extensions),
         Term::List(elems) => {
             for elem in elems.iter() {
                 collect_term_exts(elem, used_extensions, missing_extensions);

hugr-core/src/extension/resolution/types_mut.rs

@@ -222,6 +222,7 @@ pub(super) fn resolve_term_exts(
 ) -> Result<(), ExtensionResolutionError> {
     match term {
         Term::Runtime(ty) => resolve_type_exts(node, ty, extensions, used_extensions)?,
+        Term::Const(ty) => resolve_type_exts(node, ty, extensions, used_extensions)?,
         Term::List(children)
         | Term::ListConcat(children)
         | Term::Tuple(children)

hugr-core/src/import.rs

@@ -1240,8 +1240,11 @@ impl<'a> Context<'a> {
                 return Ok(Term::StaticType);
             }
 
-            if let Some([]) = self.match_symbol(term_id, model::CORE_CONST)? {
-                return Err(error_unsupported!("`{}`", model::CORE_CONST));
+            if let Some([ty]) = self.match_symbol(term_id, model::CORE_CONST)? {
+                let ty = self
+                    .import_type(ty)
+                    .map_err(|err| error_context!(err, "type of a constant"))?;
+                return Ok(TypeParam::new_const(ty));
             }
 
             if let Some([item_type]) = self.match_symbol(term_id, model::CORE_LIST_TYPE)? {

hugr-core/src/types/serialize.rs

@@ -79,6 +79,7 @@ pub(super) enum TypeParamSer {
     StaticType,
     List { param: Box<Term> },
     Tuple { params: ArrayOrTermSer },
+    Const { ty: Type },
 }
 
 #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
@@ -136,6 +137,7 @@ impl From<Term> for TermSer {
             Term::BytesType => TermSer::TypeParam(TypeParamSer::Bytes),
             Term::FloatType => TermSer::TypeParam(TypeParamSer::Float),
             Term::ListType(param) => TermSer::TypeParam(TypeParamSer::List { param }),
+            Term::Const(ty) => TermSer::TypeParam(TypeParamSer::Const { ty: *ty }),
             Term::Runtime(ty) => TermSer::TypeArg(TypeArgSer::Type { ty }),
             Term::TupleType(params) => TermSer::TypeParam(TypeParamSer::Tuple {
                 params: (*params).into(),
@@ -165,6 +167,7 @@ impl From<TermSer> for Term {
                 TypeParamSer::Float => Term::FloatType,
                 TypeParamSer::List { param } => Term::ListType(param),
                 TypeParamSer::Tuple { params } => Term::TupleType(Box::new(params.into())),
+                TypeParamSer::Const { ty } => Term::Const(Box::new(ty)),
             },
             TermSer::TypeArg(arg) => match arg {
                 TypeArgSer::Type { ty } => Term::Runtime(ty),

hugr-core/src/types/type_param.rs

@@ -139,6 +139,9 @@ pub enum Term {
     /// - see [`Term::new_var_use`]
     #[display("{_0}")]
     Variable(TermVar),
+
+    /// The type of constants for a runtime type.
+    Const(Box<Type>),
 }
 
 impl Term {
@@ -169,6 +172,11 @@ impl Term {
         Self::TupleType(Box::new(item_types.into()))
     }
 
+    /// Creates a new [`Term::Const`] from a runtime type.
+    pub fn new_const(ty: impl Into<Type>) -> Self {
+        Self::Const(Box::new(ty.into()))
+    }
+
     /// Checks if this term is a supertype of another.
     ///
     /// The subtyping relation applies primarily to terms that represent static
@@ -369,6 +377,7 @@ impl Term {
             Term::ListType(item_type) => item_type.validate(var_decls),
             Term::TupleType(item_types) => item_types.validate(var_decls),
             Term::StaticType => Ok(()),
+            Term::Const(ty) => ty.validate(var_decls),
         }
     }
 
@@ -432,6 +441,7 @@ impl Term {
             Term::ListType(item_type) => Term::new_list_type(item_type.substitute(t)),
             Term::TupleType(item_types) => Term::new_list_type(item_types.substitute(t)),
             Term::StaticType => self.clone(),
+            Term::Const(ty) => Term::new_const(ty.substitute1(t)),
         }
     }
 
@@ -593,6 +603,7 @@ impl Transformable for Term {
             Term::StaticType => Ok(false),
             TypeArg::ListConcat(lists) => lists.transform(tr),
             TypeArg::TupleConcat(tuples) => tuples.transform(tr),
+            Term::Const(ty) => ty.transform(tr),
         }
     }
 }
@@ -685,6 +696,7 @@ pub fn check_term_type(term: &Term, type_: &Term) -> Result<(), TermTypeError> {
         (Term::ListType { .. }, Term::StaticType) => Ok(()),
         (Term::TupleType(_), Term::StaticType) => Ok(()),
         (Term::RuntimeType(_), Term::StaticType) => Ok(()),
+        (Term::Const(_), Term::StaticType) => Ok(()),
 
         _ => Err(TermTypeError::TypeMismatch {
             term: term.clone(),

hugr-py/src/hugr/_serialization/tys.py

@@ -125,6 +125,14 @@ def deserialize(self) -> tys.TupleParam:
         return tys.TupleParam(params=deser_it(self.params))
 
 
+class ConstParam(BaseTypeParam):
+    tp: Literal["Const"] = "Const"
+    ty: Type
+
+    def deserialize(self) -> tys.ConstParam:
+        return tys.ConstParam(ty=self.ty.deserialize())
+
+
 class TypeParam(RootModel):
     """A type parameter."""
 
@@ -135,7 +143,8 @@ class TypeParam(RootModel):
         | FloatParam
         | BytesParam
         | ListParam
-        | TupleParam,
+        | TupleParam
+        | ConstParam,
         WrapValidator(_json_custom_error_validator),
     ] = Field(discriminator="tp")
 

hugr-py/src/hugr/tys.py

@@ -217,6 +217,23 @@ def to_model(self) -> model.Term:
         return model.Apply("core.tuple", [item_types])
 
 
+@dataclass(frozen=True)
+class ConstParam(TypeParam):
+    """Type parameter which requires a constant value."""
+
+    ty: Type
+
+    def _to_serial(self) -> stys.ConstParam:
+        return stys.ConstParam(ty=self.ty._to_serial_root())
+
+    def __str__(self) -> str:
+        return f"Const({self.ty!s})"
+
+    def to_model(self) -> model.Term:
+        ty = cast(model.Term, self.ty.to_model())
+        return model.Apply("core.const", [ty])
+
+
 # ------------------------------------------
 # --------------- TypeArg ------------------
 # ------------------------------------------

specification/schema/hugr_schema_live.json

@@ -345,6 +345,25 @@
             "title": "Const",
             "type": "object"
         },
+        "ConstParam": {
+            "additionalProperties": true,
+            "properties": {
+                "tp": {
+                    "const": "Const",
+                    "default": "Const",
+                    "title": "Tp",
+                    "type": "string"
+                },
+                "ty": {
+                    "$ref": "#/$defs/Type"
+                }
+            },
+            "required": [
+                "ty"
+            ],
+            "title": "ConstParam",
+            "type": "object"
+        },
         "CustomConst": {
             "additionalProperties": true,
             "properties": {
@@ -1781,6 +1800,7 @@
                 "mapping": {
                     "BoundedNat": "#/$defs/BoundedNatParam",
                     "Bytes": "#/$defs/BytesParam",
+                    "Const": "#/$defs/ConstParam",
                     "Float": "#/$defs/FloatParam",
                     "List": "#/$defs/ListParam",
                     "String": "#/$defs/StringParam",
@@ -1810,6 +1830,9 @@
                 },
                 {
                     "$ref": "#/$defs/TupleParam"
+                },
+                {
+                    "$ref": "#/$defs/ConstParam"
                 }
             ],
             "required": [

specification/schema/hugr_schema_strict_live.json

@@ -345,6 +345,25 @@
             "title": "Const",
             "type": "object"
         },
+        "ConstParam": {
+            "additionalProperties": false,
+            "properties": {
+                "tp": {
+                    "const": "Const",
+                    "default": "Const",
+                    "title": "Tp",
+                    "type": "string"
+                },
+                "ty": {
+                    "$ref": "#/$defs/Type"
+                }
+            },
+            "required": [
+                "ty"
+            ],
+            "title": "ConstParam",
+            "type": "object"
+        },
         "CustomConst": {
             "additionalProperties": false,
             "properties": {
@@ -1781,6 +1800,7 @@
                 "mapping": {
                     "BoundedNat": "#/$defs/BoundedNatParam",
                     "Bytes": "#/$defs/BytesParam",
+                    "Const": "#/$defs/ConstParam",
                     "Float": "#/$defs/FloatParam",
                     "List": "#/$defs/ListParam",
                     "String": "#/$defs/StringParam",
@@ -1810,6 +1830,9 @@
                 },
                 {
                     "$ref": "#/$defs/TupleParam"
+                },
+                {
+                    "$ref": "#/$defs/ConstParam"
                 }
             ],
             "required": [