guppylang-internals 0.24.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

guppylang_internals/std/_internal/compiler/list.py

@@ -328,7 +328,7 @@ def _list_new_classical(
     builder: DfBase[ops.DfParentOp], elem_type: ht.Type, args: list[Wire]
 ) -> Wire:
     # This may be simplified in the future with a `new` or `with_capacity` list op
-    # See https://github.com/CQCL/hugr/issues/1508
+    # See https://github.com/quantinuum/hugr/issues/1508
     lst = builder.load(ListVal([], elem_ty=elem_type))
     push_op = list_push(elem_type)
     for elem in args:

guppylang_internals/std/_internal/compiler/platform.py

@@ -0,0 +1,153 @@
+from dataclasses import dataclass
+from typing import ClassVar
+
+import hugr
+from hugr import Wire, ops, tys
+
+from guppylang_internals.ast_util import AstNode
+from guppylang_internals.compiler.core import CompilerContext
+from guppylang_internals.compiler.expr_compiler import array_read_bool
+from guppylang_internals.definition.custom import (
+    CustomCallCompiler,
+    CustomInoutCallCompiler,
+)
+from guppylang_internals.definition.value import CallReturnWires
+from guppylang_internals.diagnostic import Error, Note
+from guppylang_internals.error import GuppyError, InternalGuppyError
+from guppylang_internals.std._internal.compiler.array import (
+    array_clone,
+    array_map,
+    array_to_std_array,
+)
+from guppylang_internals.std._internal.compiler.tket_bool import OpaqueBool, read_bool
+from guppylang_internals.std._internal.compiler.tket_exts import RESULT_EXTENSION
+from guppylang_internals.tys.arg import Argument, ConstArg
+from guppylang_internals.tys.builtin import get_element_type, is_bool_type
+from guppylang_internals.tys.const import BoundConstVar, ConstValue
+from guppylang_internals.tys.ty import NumericType
+
+#: Maximum length of a tag in the `result` function.
+TAG_MAX_LEN = 200
+
+
+@dataclass(frozen=True)
+class TooLongError(Error):
+    title: ClassVar[str] = "Tag too long"
+    span_label: ClassVar[str] = "Result tag is too long"
+
+    @dataclass(frozen=True)
+    class Hint(Note):
+        message: ClassVar[str] = f"Result tags are limited to {TAG_MAX_LEN} bytes"
+
+    @dataclass(frozen=True)
+    class GenericHint(Note):
+        message: ClassVar[str] = "Parameter `{param}` was instantiated to `{value}`"
+        param: str
+        value: str
+
+
+class ResultCompiler(CustomCallCompiler):
+    """Custom compiler for overloads of the `result` function.
+
+    See `ArrayResultCompiler` for the compiler that handles results involving arrays.
+    """
+
+    def __init__(self, op_name: str, with_int_width: bool = False):
+        self.op_name = op_name
+        self.with_int_width = with_int_width
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        assert self.func is not None
+        [value] = args
+        ty = self.func.ty.inputs[1].ty
+        hugr_ty = ty.to_hugr(self.ctx)
+        args = [tag_to_hugr(self.type_args[0], self.ctx, self.node)]
+        if self.with_int_width:
+            args.append(tys.BoundedNatArg(NumericType.INT_WIDTH))
+        # Bool results need an extra conversion into regular hugr bools
+        if is_bool_type(ty):
+            value = self.builder.add_op(read_bool(), value)
+            hugr_ty = tys.Bool
+        op = RESULT_EXTENSION.get_op(self.op_name)
+        sig = tys.FunctionType(input=[hugr_ty], output=[])
+        self.builder.add_op(op.instantiate(args, sig), value)
+        return []
+
+
+class ArrayResultCompiler(CustomInoutCallCompiler):
+    """Custom compiler for overloads of the `result` function accepting arrays.
+
+    See `ResultCompiler` for the compiler that handles basic results.
+    """
+
+    def __init__(self, op_name: str, with_int_width: bool = False):
+        self.op_name = op_name
+        self.with_int_width = with_int_width
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        assert self.func is not None
+        array_ty = self.func.ty.inputs[1].ty
+        elem_ty = get_element_type(array_ty)
+        [tag_arg, size_arg] = self.type_args
+        [arr] = args
+
+        # As `borrow_array`s used by Guppy are linear, we need to clone it (knowing
+        # that all elements in it are copyable) to avoid linearity violations when
+        # both passing it to the result operation and returning it (as an inout
+        # argument).
+        hugr_elem_ty = elem_ty.to_hugr(self.ctx)
+        hugr_size = size_arg.to_hugr(self.ctx)
+        arr, out_arr = self.builder.add_op(array_clone(hugr_elem_ty, hugr_size), arr)
+        # For bool arrays, we furthermore need to coerce a read on all the array
+        # elements
+        if is_bool_type(elem_ty):
+            array_read = array_read_bool(self.ctx)
+            array_read = self.builder.load_function(array_read)
+            map_op = array_map(OpaqueBool, hugr_size, tys.Bool)
+            arr = self.builder.add_op(map_op, arr, array_read).out(0)
+            hugr_elem_ty = tys.Bool
+        # Turn `borrow_array` into regular `array`
+        arr = self.builder.add_op(array_to_std_array(hugr_elem_ty, hugr_size), arr).out(
+            0
+        )
+
+        hugr_ty = hugr.std.collections.array.Array(hugr_elem_ty, hugr_size)
+        sig = tys.FunctionType(input=[hugr_ty], output=[])
+        args = [tag_to_hugr(tag_arg, self.ctx, self.node), hugr_size]
+        if self.with_int_width:
+            args.append(tys.BoundedNatArg(NumericType.INT_WIDTH))
+        op = ops.ExtOp(RESULT_EXTENSION.get_op(self.op_name), signature=sig, args=args)
+        self.builder.add_op(op, arr)
+        return CallReturnWires([], [out_arr])
+
+
+def tag_to_hugr(tag_arg: Argument, ctx: CompilerContext, loc: AstNode) -> tys.TypeArg:
+    """Helper function to convert the Guppy tag comptime argument into a Hugr type arg.
+
+    Takes care of reading the tag value from the current monomorphization and checks
+    that the tag fits into `TAG_MAX_LEN`.
+    """
+    is_generic: BoundConstVar | None = None
+    match tag_arg:
+        case ConstArg(const=ConstValue(value=str(value))):
+            tag = value
+        case ConstArg(const=BoundConstVar(idx=idx) as var):
+            is_generic = var
+            assert ctx.current_mono_args is not None
+            match ctx.current_mono_args[idx]:
+                case ConstArg(const=ConstValue(value=str(value))):
+                    tag = value
+                case _:
+                    raise InternalGuppyError("Invalid tag monomorphization")
+        case _:
+            raise InternalGuppyError("Invalid tag argument")
+
+    if len(tag.encode("utf-8")) > TAG_MAX_LEN:
+        err = TooLongError(loc)
+        err.add_sub_diagnostic(TooLongError.Hint(None))
+        if is_generic:
+            err.add_sub_diagnostic(
+                TooLongError.GenericHint(None, is_generic.display_name, tag)
+            )
+        raise GuppyError(err)
+    return tys.StringArg(tag)

guppylang_internals/std/_internal/compiler/prelude.py

@@ -73,6 +73,14 @@ def panic(
     return ops.ExtOp(op_def, sig, args)
 
 
+def make_error() -> ops.ExtOp:
+    """Returns an operation that makes an error."""
+    op_def = hugr.std.PRELUDE.get_op("MakeError")
+    args: list[ht.TypeArg] = []
+    sig = ht.FunctionType([ht.USize(), hugr.std.prelude.STRING_T], [error_type()])
+    return ops.ExtOp(op_def, sig, args)
+
+
 # ------------------------------------------------------
 # --------- Custom compilers for non-native ops --------
 # ------------------------------------------------------
@@ -90,14 +98,14 @@ def build_panic(
     return builder.add_op(op, err, *args)
 
 
-def build_error(builder: DfBase[P], signal: int, msg: str) -> Wire:
+def build_static_error(builder: DfBase[P], signal: int, msg: str) -> Wire:
     """Constructs and loads a static error value."""
     val = ErrorVal(signal, msg)
     return builder.load(builder.add_const(val))
 
 
 # TODO: Common up build_unwrap_right and build_unwrap_left below once
-#  https://github.com/CQCL/hugr/issues/1596 is fixed
+#  https://github.com/quantinuum/hugr/issues/1596 is fixed
 
 
 def build_unwrap_right(
@@ -111,7 +119,7 @@ def build_unwrap_right(
     assert isinstance(result_ty, ht.Sum)
     [left_tys, right_tys] = result_ty.variant_rows
     with conditional.add_case(0) as case:
-        error = build_error(case, error_signal, error_msg)
+        error = build_static_error(case, error_signal, error_msg)
         case.set_outputs(*build_panic(case, left_tys, right_tys, error, *case.inputs()))
     with conditional.add_case(1) as case:
         case.set_outputs(*case.inputs())
@@ -134,7 +142,7 @@ def build_unwrap_left(
     with conditional.add_case(0) as case:
         case.set_outputs(*case.inputs())
     with conditional.add_case(1) as case:
-        error = build_error(case, error_signal, error_msg)
+        error = build_static_error(case, error_signal, error_msg)
         case.set_outputs(*build_panic(case, right_tys, left_tys, error, *case.inputs()))
     return conditional.to_node()
 

guppylang_internals/std/_internal/compiler/tket_exts.py

@@ -1,11 +1,13 @@
 from dataclasses import dataclass
 
+import tket_exts
 from hugr import val
 from tket_exts import (
     debug,
     futures,
+    global_phase,
     guppy,
-    opaque_bool,
+    modifier,
     qsystem,
     qsystem_random,
     qsystem_utils,
@@ -15,10 +17,12 @@ from tket_exts import (
     wasm,
 )
 
-BOOL_EXTENSION = opaque_bool()
+BOOL_EXTENSION = tket_exts.bool()
 DEBUG_EXTENSION = debug()
 FUTURES_EXTENSION = futures()
+GLOBAL_PHASE_EXTENSION = global_phase()
 GUPPY_EXTENSION = guppy()
+MODIFIER_EXTENSION = modifier()
 QSYSTEM_EXTENSION = qsystem()
 QSYSTEM_RANDOM_EXTENSION = qsystem_random()
 QSYSTEM_UTILS_EXTENSION = qsystem_utils()
@@ -31,7 +35,9 @@ TKET_EXTENSIONS = [
     BOOL_EXTENSION,
     DEBUG_EXTENSION,
     FUTURES_EXTENSION,
+    GLOBAL_PHASE_EXTENSION,
     GUPPY_EXTENSION,
+    MODIFIER_EXTENSION,
     QSYSTEM_EXTENSION,
     QSYSTEM_RANDOM_EXTENSION,
     QSYSTEM_UTILS_EXTENSION,

guppylang_internals/std/_internal/debug.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass
 from typing import ClassVar, cast
 
 from guppylang_internals.ast_util import with_loc
+from guppylang_internals.checker.core import ComptimeVariable
 from guppylang_internals.checker.errors.generic import ExpectedError
 from guppylang_internals.checker.errors.type_errors import WrongNumberOfArgsError
 from guppylang_internals.checker.expr_checker import (
@@ -14,14 +15,14 @@ from guppylang_internals.definition.custom import CustomCallChecker
 from guppylang_internals.definition.ty import TypeDef
 from guppylang_internals.diagnostic import Error
 from guppylang_internals.error import GuppyTypeError
-from guppylang_internals.nodes import StateResultExpr
-from guppylang_internals.std._internal.checker import TAG_MAX_LEN, TooLongError
+from guppylang_internals.nodes import GenericParamValue, PlaceNode, StateResultExpr
 from guppylang_internals.tys.builtin import (
     get_array_length,
     get_element_type,
     is_array_type,
     string_type,
 )
+from guppylang_internals.tys.const import Const, ConstValue
 from guppylang_internals.tys.ty import (
     FuncInput,
     FunctionType,
@@ -43,12 +44,16 @@ class StateResultChecker(CustomCallChecker):
 
     def synthesize(self, args: list[ast.expr]) -> tuple[ast.expr, Type]:
         tag, _ = ExprChecker(self.ctx).check(args[0], string_type())
-        if not isinstance(tag, ast.Constant) or not isinstance(tag.value, str):
-            raise GuppyTypeError(ExpectedError(tag, "a string literal"))
-        if len(tag.value.encode("utf-8")) > TAG_MAX_LEN:
-            err: Error = TooLongError(tag)
-            err.add_sub_diagnostic(TooLongError.Hint(None))
-            raise GuppyTypeError(err)
+        tag_value: Const
+        match tag:
+            case ast.Constant(value=str(v)):
+                tag_value = ConstValue(string_type(), v)
+            case PlaceNode(place=ComptimeVariable(static_value=str(v))):
+                tag_value = ConstValue(string_type(), v)
+            case GenericParamValue() as param_value:
+                tag_value = param_value.param.to_bound().const
+            case _:
+                raise GuppyTypeError(ExpectedError(tag, "a string literal"))
         syn_args: list[ast.expr] = [tag]
 
         if len(args) < 2:
@@ -90,6 +95,10 @@ class StateResultChecker(CustomCallChecker):
         args, ret_ty, inst = synthesize_call(func_ty, syn_args, self.node, self.ctx)
         assert len(inst) == 0, "func_ty is not generic"
         node = StateResultExpr(
-            tag=tag.value, args=args, func_ty=func_ty, array_len=array_len
+            tag_value=tag_value,
+            tag_expr=tag,
+            args=args,
+            func_ty=func_ty,
+            array_len=array_len,
         )
         return with_loc(self.node, node), ret_ty

guppylang_internals/std/_internal/util.py

@@ -129,7 +129,7 @@ def int_op(
     # Ideally we'd be able to derive the arguments from the input/output types,
     # but the amount of variables does not correlate with the signature for the
     # integer ops in hugr :/
-    # https://github.com/CQCL/hugr/blob/bfa13e59468feb0fc746677ea3b3a4341b2ed42e/hugr-core/src/std_extensions/arithmetic/int_ops.rs#L116
+    # https://github.com/quantinuum/hugr/blob/bfa13e59468feb0fc746677ea3b3a4341b2ed42e/hugr-core/src/std_extensions/arithmetic/int_ops.rs#L116
     #
     # For now, we just instantiate every type argument to a 64-bit integer.
     args: list[ht.TypeArg] = [int_arg() for _ in range(n_vars)]

guppylang_internals/tracing/object.py

@@ -539,6 +539,16 @@ class TracingDefMixin(DunderMixin):
 
     def to_guppy_object(self) -> GuppyObject:
         state = get_tracing_state()
+        defn = ENGINE.get_checked(self.id)
+        # TODO: For generic functions, we need to know an instantiation for their type
+        #  parameters. Maybe we should pass them to `to_guppy_object`? Either way, this
+        #  will require some more plumbing of type inference information through the
+        #  comptime logic. For now, let's just bail on generic functions.
+        #  See https://github.com/quantinuum/guppylang/issues/1336
+        if isinstance(defn, CallableDef) and defn.ty.parametrized:
+            raise GuppyComptimeError(
+                f"Cannot infer type parameters of generic function `{defn.name}`"
+            )
         defn, [] = state.ctx.build_compiled_def(self.id, type_args=[])
         if isinstance(defn, CompiledValueDef):
             wire = defn.load(state.dfg, state.ctx, state.node)

guppylang_internals/tracing/unpacking.py

@@ -1,7 +1,6 @@
 from typing import Any, TypeVar
 
 from hugr import ops
-from hugr import tys as ht
 from hugr.build.dfg import DfBase
 
 from guppylang_internals.ast_util import AstNode
@@ -13,7 +12,6 @@ from guppylang_internals.compiler.core import CompilerContext
 from guppylang_internals.compiler.expr_compiler import python_value_to_hugr
 from guppylang_internals.error import GuppyComptimeError, GuppyError
 from guppylang_internals.std._internal.compiler.array import array_new, unpack_array
-from guppylang_internals.std._internal.compiler.prelude import build_unwrap
 from guppylang_internals.tracing.frozenlist import frozenlist
 from guppylang_internals.tracing.object import (
     GuppyObject,
@@ -71,9 +69,7 @@ def unpack_guppy_object(
                     # them as Guppy objects here
                     return obj
                 elem_ty = get_element_type(ty)
-                opt_elems = unpack_array(builder, obj._use_wire(None))
-                err = "Non-copyable array element has already been used"
-                elems = [build_unwrap(builder, opt_elem, err) for opt_elem in opt_elems]
+                elems = unpack_array(builder, obj._use_wire(None))
                 obj_list = [
                     unpack_guppy_object(GuppyObject(elem_ty, wire), builder, frozen)
                     for wire in elems
@@ -128,11 +124,8 @@ def guppy_object_from_py(
                         f"Element at index {i + 1} does not match the type of "
                         f"previous elements. Expected `{elem_ty}`, got `{obj._ty}`."
                     )
-            hugr_elem_ty = ht.Option(elem_ty.to_hugr(ctx))
-            wires = [
-                builder.add_op(ops.Tag(1, hugr_elem_ty), obj._use_wire(None))
-                for obj in objs
-            ]
+            hugr_elem_ty = elem_ty.to_hugr(ctx)
+            wires = [obj._use_wire(None) for obj in objs]
             return GuppyObject(
                 array_type(elem_ty, len(vs)),
                 builder.add_op(array_new(hugr_elem_ty, len(vs)), *wires),
@@ -172,26 +165,32 @@ def update_packed_value(v: Any, obj: "GuppyObject", builder: DfBase[P]) -> bool:
             assert isinstance(obj._ty, NoneType)
         case tuple(vs):
             assert isinstance(obj._ty, TupleType)
-            wires = builder.add_op(ops.UnpackTuple(), obj._use_wire(None)).outputs()
-            for v, ty, wire in zip(vs, obj._ty.element_types, wires, strict=True):
-                success = update_packed_value(v, GuppyObject(ty, wire), builder)
+            wire_iterator = builder.add_op(
+                ops.UnpackTuple(), obj._use_wire(None)
+            ).outputs()
+            for v, ty, out_wire in zip(
+                vs, obj._ty.element_types, wire_iterator, strict=True
+            ):
+                success = update_packed_value(v, GuppyObject(ty, out_wire), builder)
                 if not success:
                     return False
         case GuppyStructObject(_ty=ty, _field_values=values):
             assert obj._ty == ty
-            wires = builder.add_op(ops.UnpackTuple(), obj._use_wire(None)).outputs()
-            for field, wire in zip(ty.fields, wires, strict=True):
+            wire_iterator = builder.add_op(
+                ops.UnpackTuple(), obj._use_wire(None)
+            ).outputs()
+            for field, out_wire in zip(ty.fields, wire_iterator, strict=True):
                 v = values[field.name]
-                success = update_packed_value(v, GuppyObject(field.ty, wire), builder)
+                success = update_packed_value(
+                    v, GuppyObject(field.ty, out_wire), builder
+                )
                 if not success:
                     values[field.name] = obj
         case list(vs) if len(vs) > 0:
             assert is_array_type(obj._ty)
             elem_ty = get_element_type(obj._ty)
-            opt_wires = unpack_array(builder, obj._use_wire(None))
-            err = "Non-droppable array element has already been used"
-            for i, (v, opt_wire) in enumerate(zip(vs, opt_wires, strict=True)):
-                (wire,) = build_unwrap(builder, opt_wire, err).outputs()
+            wires = unpack_array(builder, obj._use_wire(None))
+            for i, (v, wire) in enumerate(zip(vs, wires, strict=True)):
                 success = update_packed_value(v, GuppyObject(elem_ty, wire), builder)
                 if not success:
                     vs[i] = obj

guppylang_internals/tys/arg.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, TypeAlias
 
 from hugr import tys as ht
@@ -18,7 +18,7 @@ from guppylang_internals.tys.const import (
     ConstValue,
     ExistentialConstVar,
 )
-from guppylang_internals.tys.var import ExistentialVar
+from guppylang_internals.tys.var import BoundVar, ExistentialVar
 
 if TYPE_CHECKING:
     from guppylang_internals.tys.ty import Type
@@ -45,19 +45,29 @@ class ArgumentBase(ToHugr[ht.TypeArg], Transformable["Argument"], ABC):
     def unsolved_vars(self) -> set[ExistentialVar]:
         """The existential type variables contained in this argument."""
 
+    @property
+    @abstractmethod
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this argument."""
+
 
 @dataclass(frozen=True)
 class TypeArg(ArgumentBase):
     """Argument that can be instantiated for a `TypeParameter`."""
 
     # The type to instantiate
-    ty: "Type"
+    ty: "Type" = field(hash=False)  # Types are not hashable
 
     @property
     def unsolved_vars(self) -> set[ExistentialVar]:
         """The existential type variables contained in this argument."""
         return self.ty.unsolved_vars
 
+    @property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this type."""
+        return self.ty.bound_vars
+
     def to_hugr(self, ctx: ToHugrContext) -> ht.TypeTypeArg:
         """Computes the Hugr representation of the argument."""
         ty: ht.Type = self.ty.to_hugr(ctx)
@@ -84,6 +94,11 @@ class ConstArg(ArgumentBase):
         """The existential const variables contained in this argument."""
         return self.const.unsolved_vars
 
+    @property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this argument."""
+        return self.const.bound_vars
+
     def to_hugr(self, ctx: ToHugrContext) -> ht.TypeArg:
         """Computes the Hugr representation of this argument."""
         from guppylang_internals.tys.ty import NumericType

guppylang_internals/tys/builtin.py

@@ -177,13 +177,10 @@ def _array_to_hugr(args: Sequence[Argument], ctx: ToHugrContext) -> ht.Type:
     assert isinstance(ty_arg, TypeArg)
     assert isinstance(len_arg, ConstArg)
 
-    # Linear elements are turned into an optional to enable unsafe indexing.
-    # See `ArrayGetitemCompiler` for details.
-    # Same also for classical arrays, see https://github.com/CQCL/guppylang/issues/629
-    elem_ty = ht.Option(ty_arg.ty.to_hugr(ctx))
+    elem_ty = ty_arg.ty.to_hugr(ctx)
     hugr_arg = len_arg.to_hugr(ctx)
 
-    return hugr.std.collections.value_array.ValueArray(elem_ty, hugr_arg)
+    return hugr.std.collections.borrow_array.BorrowArray(elem_ty, hugr_arg)
 
 
 def _frozenarray_to_hugr(args: Sequence[Argument], ctx: ToHugrContext) -> ht.Type:

guppylang_internals/tys/const.py

@@ -8,6 +8,7 @@ from guppylang_internals.tys.var import BoundVar, ExistentialVar
 
 if TYPE_CHECKING:
     from guppylang_internals.tys.arg import ConstArg
+    from guppylang_internals.tys.subst import Subst
     from guppylang_internals.tys.ty import Type
 
 
@@ -39,6 +40,11 @@ class ConstBase(Transformable["Const"], ABC):
         """The existential type variables contained in this constant."""
         return set()
 
+    @property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this constant."""
+        return self.ty.bound_vars
+
     def __str__(self) -> str:
         from guppylang_internals.tys.printing import TypePrinter
 
@@ -48,16 +54,18 @@ class ConstBase(Transformable["Const"], ABC):
         """Accepts a visitor on this constant."""
         visitor.visit(self)
 
-    def transform(self, transformer: Transformer, /) -> "Const":
-        """Accepts a transformer on this constant."""
-        return transformer.transform(self) or self.cast()
-
     def to_arg(self) -> "ConstArg":
         """Wraps this constant into a type argument."""
         from guppylang_internals.tys.arg import ConstArg
 
         return ConstArg(self.cast())
 
+    def substitute(self, subst: "Subst") -> "Const":
+        """Substitutes existential variables in this constant."""
+        from guppylang_internals.tys.subst import Substituter
+
+        return self.transform(Substituter(subst))
+
 
 @dataclass(frozen=True)
 class ConstValue(ConstBase):
@@ -74,6 +82,10 @@ class ConstValue(ConstBase):
         """Casts an implementor of `ConstBase` into a `Const`."""
         return self
 
+    def transform(self, transformer: Transformer, /) -> "Const":
+        """Accepts a transformer on this constant."""
+        return transformer.transform(self) or self
+
 
 @dataclass(frozen=True)
 class BoundConstVar(BoundVar, ConstBase):
@@ -84,10 +96,21 @@ class BoundConstVar(BoundVar, ConstBase):
     `BoundConstVar(idx=0)`.
     """
 
+    @property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this constant."""
+        return {self} | self.ty.bound_vars
+
     def cast(self) -> "Const":
         """Casts an implementor of `ConstBase` into a `Const`."""
         return self
 
+    def transform(self, transformer: Transformer, /) -> "Const":
+        """Accepts a transformer on this constant."""
+        return transformer.transform(self) or BoundConstVar(
+            transformer.transform(self.ty) or self.ty, self.display_name, self.idx
+        )
+
 
 @dataclass(frozen=True)
 class ExistentialConstVar(ExistentialVar, ConstBase):
@@ -110,5 +133,11 @@ class ExistentialConstVar(ExistentialVar, ConstBase):
         """Casts an implementor of `ConstBase` into a `Const`."""
         return self
 
+    def transform(self, transformer: Transformer, /) -> "Const":
+        """Accepts a transformer on this constant."""
+        return transformer.transform(self) or ExistentialConstVar(
+            transformer.transform(self.ty) or self.ty, self.display_name, self.id
+        )
+
 
 Const: TypeAlias = ConstValue | BoundConstVar | ExistentialConstVar

guppylang_internals/tys/errors.py

@@ -5,7 +5,7 @@ from guppylang_internals.diagnostic import Error, Help, Note
 
 if TYPE_CHECKING:
     from guppylang_internals.definition.parameter import ParamDef
-    from guppylang_internals.tys.ty import Type
+    from guppylang_internals.tys.ty import Type, UnitaryFlags
 
 
 @dataclass(frozen=True)
@@ -182,3 +182,25 @@ class InvalidFlagError(Error):
 class FlagNotAllowedError(Error):
     title: ClassVar[str] = "Invalid annotation"
     span_label: ClassVar[str] = "`@` type annotations are not allowed in this position"
+
+
+@dataclass(frozen=True)
+class UnitaryCallError(Error):
+    title: ClassVar[str] = "Unitary constraint violation"
+    span_label: ClassVar[str] = (
+        "This function cannot be called in a {render_flags} context"
+    )
+    flags: "UnitaryFlags"
+
+    @property
+    def render_flags(self) -> str:
+        from guppylang_internals.tys.ty import UnitaryFlags
+
+        if self.flags == UnitaryFlags.Dagger:
+            return "dagger"
+        elif self.flags == UnitaryFlags.Control:
+            return "control"
+        elif self.flags == UnitaryFlags.Power:
+            return "power"
+        else:
+            return "unitary"