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

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/param.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from typing import TYPE_CHECKING, TypeAlias
 
 from hugr import tys as ht
@@ -17,9 +17,9 @@ from guppylang_internals.tys.errors import WrongNumberOfTypeArgsError
 from guppylang_internals.tys.var import ExistentialVar
 
 if TYPE_CHECKING:
+    from guppylang_internals.tys.subst import PartialInst
     from guppylang_internals.tys.ty import Type
 
-
 # We define the `Parameter` type as a union of all `ParameterBase` subclasses defined
 # below. This models an algebraic data type and enables exhaustiveness checking in
 # pattern matches etc.
@@ -74,6 +74,10 @@ class ParameterBase(ToHugr[ht.TypeParam], ABC):
         parameter.
         """
 
+    @abstractmethod
+    def instantiate_bounds(self, inst: "PartialInst") -> Self:
+        """Instantiates bound variables mentioned in parameter bounds"""
+
 
 @dataclass(frozen=True)
 class TypeParam(ParameterBase):
@@ -142,10 +146,17 @@ class TypeParam(ParameterBase):
             BoundTypeVar(self.name, idx, self.must_be_copyable, self.must_be_droppable)
         )
 
+    def instantiate_bounds(self, inst: "PartialInst") -> "TypeParam":
+        """Instantiates bound variables mentioned in parameter bounds"""
+        # For now, type parameters don't have any bounds that could be instantiated
+        return self
+
     def to_hugr(self, ctx: ToHugrContext) -> ht.TypeParam:
         """Computes the Hugr representation of the parameter."""
         return ht.TypeTypeParam(
-            bound=ht.TypeBound.Linear if self.can_be_linear else ht.TypeBound.Copyable
+            bound=ht.TypeBound.Copyable
+            if self.must_be_copyable
+            else ht.TypeBound.Linear
         )
 
     def __str__(self) -> str:
@@ -157,18 +168,12 @@ class TypeParam(ParameterBase):
 class ConstParam(ParameterBase):
     """A parameter of kind constant. Used to define fixed-size arrays etc."""
 
-    ty: "Type"
+    ty: "Type" = field(hash=False)
 
     #: Marker to annotate if this parameter was implicitly generated by a `@comptime`
     #: annotated argument in a function signature.
     from_comptime_arg: bool = field(default=False, kw_only=True)
 
-    def __post_init__(self) -> None:
-        if self.ty.unsolved_vars:
-            raise InternalGuppyError(
-                "Attempted to create constant param with unsolved type"
-            )
-
     def with_idx(self, idx: int) -> "ConstParam":
         """Returns a copy of the parameter with a new index."""
         return ConstParam(idx, self.name, self.ty)
@@ -178,13 +183,16 @@ class ConstParam(ParameterBase):
 
         Raises a user error if the argument is not valid.
         """
+        from guppylang_internals.tys.ty import unify
+
         match arg:
             case ConstArg(const):
-                if const.ty != self.ty:
+                subst = unify(const.ty, self.ty, {})
+                if subst is None:
                     raise GuppyTypeError(
                         TypeMismatchError(loc, self.ty, const.ty, kind="argument")
                     )
-                return arg
+                return ConstArg(replace(const, ty=const.ty.substitute(subst)))
             case TypeArg(ty=ty):
                 err = ExpectedError(
                     loc, f"expression of type `{self.ty}`", got=f"type `{ty}`"
@@ -208,6 +216,13 @@ class ConstParam(ParameterBase):
             idx = self.idx
         return ConstArg(BoundConstVar(self.ty, self.name, idx))
 
+    def instantiate_bounds(self, inst: "PartialInst") -> "ConstParam":
+        """Instantiates bound variables mentioned in parameter bounds"""
+        from guppylang_internals.tys.subst import Instantiator
+
+        instantiator = Instantiator(inst)
+        return replace(self, ty=self.ty.transform(instantiator))
+
     def to_hugr(self, ctx: ToHugrContext) -> ht.TypeParam:
         """Computes the Hugr representation of the parameter."""
         from guppylang_internals.tys.ty import NumericType
@@ -231,6 +246,7 @@ def check_all_args(
     args: Sequence[Argument],
     type_name: str,
     loc: AstNode | None = None,
+    arg_locs: Sequence[AstNode] | None = None,
 ) -> None:
     """Checks a list of arguments against the given parameters.
 
@@ -245,7 +261,6 @@ def check_all_args(
         raise GuppyError(WrongNumberOfTypeArgsError(loc, exp, act, type_name))
 
     # Now check that the kinds match up
-    for param, arg in zip(params, args, strict=True):
-        # TODO: The error location is bad. We want the location of `arg`, not of the
-        #  whole thing.
-        param.check_arg(arg, loc)
+    for i, (param, arg) in enumerate(zip(params, args, strict=True)):
+        arg_loc = arg_locs[i] if arg_locs else loc
+        param.instantiate_bounds(args).check_arg(arg, arg_loc)

guppylang_internals/tys/parsing.py

@@ -39,7 +39,6 @@ from guppylang_internals.tys.errors import (
     WrongNumberOfTypeArgsError,
 )
 from guppylang_internals.tys.param import ConstParam, Parameter, TypeParam
-from guppylang_internals.tys.subst import BoundVarFinder
 from guppylang_internals.tys.ty import (
     FuncInput,
     FunctionType,
@@ -295,7 +294,13 @@ def check_function_arg(
 
 if sys.version_info >= (3, 12):
 
-    def parse_parameter(node: ast.type_param, idx: int, globals: Globals) -> Parameter:
+    def parse_parameter(
+        node: ast.type_param,
+        idx: int,
+        globals: Globals,
+        param_var_mapping: dict[str, Parameter],
+        allow_free_vars: bool = False,
+    ) -> Parameter:
         """Parses a `Variable: Bound` generic type parameter declaration."""
         if isinstance(node, ast.TypeVarTuple | ast.ParamSpec):
             raise GuppyError(UnsupportedError(node, "Variadic generic parameters"))
@@ -331,18 +336,10 @@ if sys.version_info >= (3, 12):
                 # parameters, so we pass an empty dict as the `param_var_mapping`.
                 # TODO: In the future we might want to allow stuff like
                 #   `def foo[T, XS: array[T, 42]]` and so on
-                ctx = TypeParsingCtx(globals, param_var_mapping={})
+                ctx = TypeParsingCtx(globals, param_var_mapping, allow_free_vars)
                 ty = type_from_ast(bound, ctx)
                 if not ty.copyable or not ty.droppable:
                     raise GuppyError(LinearConstParamError(bound, ty))
-
-                # TODO: For now we can only do `nat` const args since they lower to
-                #  Hugr bounded nats. Extend to arbitrary types via monomorphization.
-                #  See https://github.com/CQCL/guppylang/issues/1008
-                if ty != NumericType(NumericType.Kind.Nat):
-                    raise GuppyError(
-                        UnsupportedError(bound, f"`{ty}` generic parameters")
-                    )
                 return ConstParam(idx, node.name, ty)
 
 
@@ -363,16 +360,6 @@ def type_with_flags_from_ast(
                 flags |= InputFlags.Comptime
                 if not ty.copyable or not ty.droppable:
                     raise GuppyError(LinearComptimeError(node.right, ty))
-                # For now, we don't allow comptime annotations on generic inputs
-                # TODO: In the future we might want to allow stuff like
-                #  `def foo[T: (Copy, Discard](x: T @comptime)`.
-                #   Also see the todo in `parse_parameter`.
-                var_finder = BoundVarFinder()
-                ty.visit(var_finder)
-                if var_finder.bound_vars:
-                    raise GuppyError(
-                        UnsupportedError(node.left, "Generic comptime arguments")
-                    )
             case _:
                 raise GuppyError(InvalidFlagError(node.right))
         return ty, flags

guppylang_internals/tys/qubit.py

@@ -0,0 +1,27 @@
+import functools
+from typing import cast
+
+from guppylang_internals.definition.ty import TypeDef
+from guppylang_internals.tys.ty import Type
+
+
+@functools.cache
+def qubit_ty() -> Type:
+    """Returns the qubit type. Beware that this function imports guppylang definitions,
+    so, if called before the definitions are registered,
+    it might result in circular imports.
+    """
+    from guppylang.defs import GuppyDefinition
+    from guppylang.std.quantum import qubit
+
+    assert isinstance(qubit, GuppyDefinition)
+    qubit_ty = cast(TypeDef, qubit.wrapped).check_instantiate([])
+    return qubit_ty
+
+
+def is_qubit_ty(ty: Type) -> bool:
+    """Checks if the given type is the qubit type.
+    This function results in circular imports if called
+    before qubit types are registered.
+    """
+    return ty == qubit_ty()

guppylang_internals/tys/subst.py

@@ -4,7 +4,7 @@ from typing import Any
 
 from guppylang_internals.error import InternalGuppyError
 from guppylang_internals.tys.arg import Argument, ConstArg, TypeArg
-from guppylang_internals.tys.common import Transformer, Visitor
+from guppylang_internals.tys.common import Transformer
 from guppylang_internals.tys.const import (
     BoundConstVar,
     Const,
@@ -18,7 +18,7 @@ from guppylang_internals.tys.ty import (
     Type,
     TypeBase,
 )
-from guppylang_internals.tys.var import BoundVar, ExistentialVar
+from guppylang_internals.tys.var import ExistentialVar
 
 Subst = dict[ExistentialVar, Type | Const]
 Inst = Sequence[Argument]
@@ -51,7 +51,8 @@ class Substituter(Transformer):
 class Instantiator(Transformer):
     """Type transformer that instantiates bound variables."""
 
-    def __init__(self, inst: Inst) -> None:
+    def __init__(self, inst: PartialInst, allow_partial: bool = False) -> None:
+        self.allow_partial = allow_partial
         self.inst = inst
 
     @functools.singledispatchmethod
@@ -63,6 +64,8 @@ class Instantiator(Transformer):
         # Instantiate if type for the index is available
         if ty.idx < len(self.inst):
             arg = self.inst[ty.idx]
+            if arg is None and self.allow_partial:
+                return None
             assert isinstance(arg, TypeArg)
             return arg.ty
 
@@ -76,6 +79,8 @@ class Instantiator(Transformer):
         # Instantiate if const value for the index is available
         if c.idx < len(self.inst):
             arg = self.inst[c.idx]
+            if arg is None and self.allow_partial:
+                return None
             assert isinstance(arg, ConstArg)
             return arg.const
 
@@ -87,26 +92,3 @@ class Instantiator(Transformer):
         if ty.parametrized:
             raise InternalGuppyError("Tried to instantiate under binder")
         return None
-
-
-class BoundVarFinder(Visitor):
-    """Type visitor that looks for occurrences of bound variables."""
-
-    bound_vars: set[BoundVar]
-
-    def __init__(self) -> None:
-        self.bound_vars = set()
-
-    @functools.singledispatchmethod
-    def visit(self, ty: Any) -> bool:  # type: ignore[override]
-        return False
-
-    @visit.register
-    def _transform_BoundTypeVar(self, ty: BoundTypeVar) -> bool:
-        self.bound_vars.add(ty)
-        return False
-
-    @visit.register
-    def _transform_BoundConstVar(self, c: BoundConstVar) -> bool:
-        self.bound_vars.add(c)
-        return False

guppylang_internals/tys/ty.py

@@ -57,14 +57,11 @@ class TypeBase(ToHugr[ht.Type], Transformable["Type"], ABC):
         return not self.copyable and self.droppable
 
     @cached_property
-    @abstractmethod
     def hugr_bound(self) -> ht.TypeBound:
-        """The Hugr bound of this type, i.e. `Any`, `Copyable`, or `Equatable`.
-
-        This needs to be specified explicitly, since opaque nonlinear types in a Hugr
-        extension could be either declared as copyable or equatable. If we don't get the
-        bound exactly right during serialisation, the Hugr validator will complain.
-        """
+        """The Hugr bound of this type, i.e. `Any` or `Copyable`."""
+        if self.linear or self.affine:
+            return ht.TypeBound.Linear
+        return ht.TypeBound.Copyable
 
     @abstractmethod
     def cast(self) -> "Type":
@@ -79,6 +76,11 @@ class TypeBase(ToHugr[ht.Type], Transformable["Type"], ABC):
         """The existential type variables contained in this type."""
         return set()
 
+    @cached_property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this type."""
+        return set()
+
     def substitute(self, subst: "Subst") -> "Type":
         """Substitutes existential variables in this type."""
         from guppylang_internals.tys.subst import Substituter
@@ -158,13 +160,17 @@ class ParametrizedTypeBase(TypeBase, ABC):
         """The existential type variables contained in this type."""
         return set().union(*(arg.unsolved_vars for arg in self.args))
 
+    @cached_property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this type."""
+        return set().union(*(arg.bound_vars for arg in self.args))
+
     @cached_property
     def hugr_bound(self) -> ht.TypeBound:
-        """The Hugr bound of this type, i.e. `Any`, `Copyable`, or `Equatable`."""
-        if self.linear:
-            return ht.TypeBound.Linear
+        """The Hugr bound of this type, i.e. `Any` or `Copyable`."""
         return ht.TypeBound.join(
-            *(arg.ty.hugr_bound for arg in self.args if isinstance(arg, TypeArg))
+            super().hugr_bound,
+            *(arg.ty.hugr_bound for arg in self.args if isinstance(arg, TypeArg)),
         )
 
     def visit(self, visitor: Visitor) -> None:
@@ -187,14 +193,10 @@ class BoundTypeVar(TypeBase, BoundVar):
     copyable: bool
     droppable: bool
 
-    @cached_property
-    def hugr_bound(self) -> ht.TypeBound:
-        """The Hugr bound of this type, i.e. `Any`, `Copyable`, or `Equatable`."""
-        if self.linear:
-            return ht.TypeBound.Linear
-        # We're conservative and don't require equatability for non-linear variables.
-        # This is fine since Guppy doesn't use the equatable feature anyways.
-        return ht.TypeBound.Copyable
+    @property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this type."""
+        return {self}
 
     def cast(self) -> "Type":
         """Casts an implementor of `TypeBase` into a `Type`."""
@@ -426,6 +428,14 @@ class FunctionType(ParametrizedTypeBase):
         """Whether the function is parametrized."""
         return len(self.params) > 0
 
+    @cached_property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this type."""
+        if self.parametrized:
+            # Ensures that we don't look inside quantifiers
+            return set()
+        return super().bound_vars
+
     def cast(self) -> "Type":
         """Casts an implementor of `TypeBase` into a `Type`."""
         return self
@@ -506,7 +516,7 @@ class FunctionType(ParametrizedTypeBase):
             # However, we have to down-shift the de Bruijn index.
             if arg is None:
                 param = param.with_idx(len(remaining_params))
-                remaining_params.append(param)
+                remaining_params.append(param.instantiate_bounds(full_inst))
                 arg = param.to_bound()
 
             # Set the `preserve` flag for instantiated tuples and None
@@ -651,7 +661,7 @@ class OpaqueType(ParametrizedTypeBase):
 
     @property
     def hugr_bound(self) -> ht.TypeBound:
-        """The Hugr bound of this type, i.e. `Any`, `Copyable`, or `Equatable`."""
+        """The Hugr bound of this type, i.e. `Any` or `Copyable`."""
         if self.defn.bound is not None:
             return self.defn.bound
         return super().hugr_bound

{guppylang_internals-0.24.0.dist-info → guppylang_internals-0.25.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guppylang-internals
-Version: 0.24.0
+Version: 0.25.0
 Summary: Compiler internals for `guppylang` package.
 Author-email: Mark Koch <mark.koch@quantinuum.com>, TKET development team <tket-support@quantinuum.com>
 Maintainer-email: Mark Koch <mark.koch@quantinuum.com>, TKET development team <tket-support@quantinuum.com>
@@ -219,8 +219,8 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Compilers
 Requires-Python: <4,>=3.10
-Requires-Dist: hugr~=0.13.1
-Requires-Dist: tket-exts~=0.11.0
+Requires-Dist: hugr~=0.14.1
+Requires-Dist: tket-exts~=0.12.0
 Requires-Dist: typing-extensions<5,>=4.9.0
 Provides-Extra: pytket
 Requires-Dist: pytket>=1.34; extra == 'pytket'

{guppylang_internals-0.24.0.dist-info → guppylang_internals-0.25.0.dist-info}/RECORD

@@ -1,54 +1,56 @@
-guppylang_internals/__init__.py,sha256=DGSTdGFDWX6LAry7XIDSqKcMw7qI9NIEAI_aS2gLKcc,130
-guppylang_internals/ast_util.py,sha256=Y_7MoilGpahv7tJ1xN5nVGIELZlhk-5h_9AbI3qixZg,11839
+guppylang_internals/__init__.py,sha256=EgbPDr6Utan7jHefvmK8YWd_y5KDx9mb6kOXetg5X_4,130
+guppylang_internals/ast_util.py,sha256=WHa7axpGrdsjzQk3iw3reDzYlcmsx0HsNH4Qbqwjjig,12531
 guppylang_internals/decorator.py,sha256=AWfPMMXzq5YC8nfB6DOwnRsrWKztuUK19n8APllgQ2w,10928
 guppylang_internals/diagnostic.py,sha256=VCpIhyVD8KPtk0GDYMa8XH0lKVsRbsWNu_ucE2jQT2I,18395
 guppylang_internals/dummy_decorator.py,sha256=LXTXrdcrr55YzerX3qrHS23q6S9pVdpUAvhprWzKH6E,2330
 guppylang_internals/engine.py,sha256=enloUzh4-2Ac0L7UCIzsMvsjzHvWIy8MvDoT2xhPdKk,10625
 guppylang_internals/error.py,sha256=fjHsbglnH9GtcsLF4sSry7FTjrLoiyQ-L1JS3uGirx0,3393
-guppylang_internals/experimental.py,sha256=ad3Ti6ncUdQA6MiXRyj45GvzlSx3Ww7PhrEpnrb79kI,2937
+guppylang_internals/experimental.py,sha256=yERQgpT7P-x0-nr4gU4PdUCntByQwF2I9rfjpWtgqn4,3115
 guppylang_internals/ipython_inspect.py,sha256=rY2DpSpSBrRk0IZmuoz7jh35kGZHQnHLAQQFdb_-WnI,931
-guppylang_internals/nodes.py,sha256=Wvf12iU6rhx7RgqbbtcGPkiJwtQjgt6NMkYzmzZPAHc,9580
+guppylang_internals/nodes.py,sha256=rJMtAJL_eRnrI6MZkweAWs1gYteCP3HSZM9BEkyAW7Q,12803
 guppylang_internals/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/span.py,sha256=8rWzAAipWunhhyCp44qdUAPmOfAXkEMvicK0PYc3tTg,4986
 guppylang_internals/cfg/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/cfg/analysis.py,sha256=fD3cY0bZ85iNWcmLAXFaXwcdCfB7gzssKjYfsm1J-wQ,8365
-guppylang_internals/cfg/bb.py,sha256=k2ww5WpFkM_1G7Y_1FzSzBlf7Z83X2j1qFpBIK95dlo,7877
-guppylang_internals/cfg/builder.py,sha256=9WExlNvZkO0NcTgr4zATxk7Oys8Uas2me1leeDTwR1Y,23779
+guppylang_internals/cfg/bb.py,sha256=TxV5yHRqiH86lvLR0g4EZ4fs7S6Axoof1l0TIAZArJM,8591
+guppylang_internals/cfg/builder.py,sha256=UJXLzCNEA8nKCrRV3Y2AhMVwncbiHFD5m4t8zIKD5Ag,27630
 guppylang_internals/cfg/cfg.py,sha256=G6wTHtyRYcBN7FIwyIQnt3akVjM-Rl37PEXAaujplMg,4355
 guppylang_internals/checker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/checker/cfg_checker.py,sha256=SH_89mAQLNBVesERm9alJJ2h0xzQFzCA5uKBD2VfJms,13472
-guppylang_internals/checker/core.py,sha256=PI4vLkv_u799Ae0JpKsN4JIV8Toxf16DRyRg1V4Q2lM,18006
-guppylang_internals/checker/expr_checker.py,sha256=AuSWTLu3rBGIq8Uw-Vj-nS0aLDI4VUuXqIEiP2PoNWg,58199
-guppylang_internals/checker/func_checker.py,sha256=rp7_W79f5wqkB4qv5qrP3hGYJXpW3L1mpeeSGtxYJAI,15906
-guppylang_internals/checker/linearity_checker.py,sha256=cHvJSqFKWpkLqO7uAwz7OBmxtAi8ZN_K7afMrspkXy4,34719
-guppylang_internals/checker/stmt_checker.py,sha256=J1LT6rae8a_p2pbdHKJQTZdeDkZak017icotWWyBQHA,18827
+guppylang_internals/checker/core.py,sha256=MHCHleEKRvI5mCV5w4VGdM51qjqHLb-2hFDpjG_tvCM,18188
+guppylang_internals/checker/expr_checker.py,sha256=G9NrLmr3vv9XZp0l5N5lOdMZdyCOWgwYhTYrlaxVEZA,59706
+guppylang_internals/checker/func_checker.py,sha256=e9FrEe72Y-KUchXtGljRUTr1tA4uwKVRv8uQVlInicA,15925
+guppylang_internals/checker/linearity_checker.py,sha256=3RcJvXxgVZYsDijXpxubekpF1-XnNqKqaKF58VXorYg,37463
+guppylang_internals/checker/modifier_checker.py,sha256=REzu1DVVutKlGAas2Gu8HKdPN83QlY9XHyxrotdF8vM,4042
+guppylang_internals/checker/stmt_checker.py,sha256=paUBaAwx3QRpJAonND8wBpO4FxcNb4iPXMzImB11T9A,20785
 guppylang_internals/checker/errors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/checker/errors/comptime_errors.py,sha256=ee42lnVjXbjqirjp6vYaRvbKKexeNV08px1Kqu9eXn8,3436
-guppylang_internals/checker/errors/generic.py,sha256=485uhGANlWiKZrYpD0Fjh3lCqnL3QwqROzGZhwsiSug,1183
+guppylang_internals/checker/errors/generic.py,sha256=r-BiSrmJh9jfXlxE029GMQ8yj30_qOTW2RAQsd3HYzs,2050
 guppylang_internals/checker/errors/linearity.py,sha256=VLGvwzfW6uljNjYUEIxNkgt6s3q9-yo1O22BoTiS4Xs,8922
-guppylang_internals/checker/errors/type_errors.py,sha256=1rEl8nVnveJXLc4CRKmNw2inKnWkXr3u6Iy3scepNSU,10221
+guppylang_internals/checker/errors/type_errors.py,sha256=KUmcpN3tGLI_8BogcGKfV_N5BO7yqEBPgyHmf8hk-3M,10619
 guppylang_internals/checker/errors/wasm.py,sha256=tRpNhC8IZBkv6Nkn_dMRwGpDdZklv7UZdlYBu4WqI1A,874
 guppylang_internals/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/compiler/cfg_compiler.py,sha256=nGQmPYhXzicZ16_-8sgFC-sfLxMFEDSGd1Xf0j7LTK0,9039
-guppylang_internals/compiler/core.py,sha256=W1k_vQR3hePw97SQiR9mB2gxtMq_ht25eD4B7u93JNg,29000
-guppylang_internals/compiler/expr_compiler.py,sha256=KJyR22YjSz9ya3Ug_w4Esgnar3NOQ1zyLoWQR_e-s9E,41282
+guppylang_internals/compiler/core.py,sha256=mw7mQXQoBrt28NxjQ-3JSKhYVyVsDC21YVDaAaDtWBo,31518
+guppylang_internals/compiler/expr_compiler.py,sha256=Km9ne1yd6A9ykpZvNMtZyktPagjJCHoZWEpx2M8i7gY,38600
 guppylang_internals/compiler/func_compiler.py,sha256=0bo28RNsFZDYmllle-yFUXKC0UJsLl2TVjr3gvDMJVA,3377
 guppylang_internals/compiler/hugr_extension.py,sha256=eFUcxzBZoVzXV-AqEOJlh_rJkyuS3vFv1WKGOHjloJs,7966
+guppylang_internals/compiler/modifier_compiler.py,sha256=3KtA0YvMpj_JTCQAOH2leRQPFX1nyxFppAdEPWcjuk0,6315
 guppylang_internals/compiler/qtm_platform_extension.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-guppylang_internals/compiler/stmt_compiler.py,sha256=Td1-xgrYtQMstpy_qh90baCvwYXRk95M7SOJ7qyXO2s,9201
+guppylang_internals/compiler/stmt_compiler.py,sha256=cdOgqzRVP1hYeGbGftgY8LlFRHLWdgFPjlhK-khoMvw,9340
 guppylang_internals/definition/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/definition/common.py,sha256=Me7gpCTzOqDv7eRv6Wo5ynsMYy6MEDpeX9uY2acYRDI,6927
 guppylang_internals/definition/const.py,sha256=71QVX3xqSaC0u4bsYHPbR_0Csz1Es-P7HHGxbTZXfNI,2283
-guppylang_internals/definition/custom.py,sha256=eozLnrEFvOknYuJZnnar4jSV3V09V5qbCC7rzhHjWt0,17929
-guppylang_internals/definition/declaration.py,sha256=xZOyWgivJou8smL4wpIXWXuAzHwtcBfhTJ6LNrS8T-c,5894
+guppylang_internals/definition/custom.py,sha256=V3KU92rIonEdWyCwt3Rfkblic-XH-V0moGCTws3Sgbc,19539
+guppylang_internals/definition/declaration.py,sha256=rmZdYHTTxjALfWmEfoNMVQ9hBmeV3o3VNXm9gcs3ubc,5883
 guppylang_internals/definition/extern.py,sha256=hEajRYaapKIfX9J7scnusQHc1e_bCxB4oUVWZ-D4c8o,2878
 guppylang_internals/definition/function.py,sha256=oz-4dk5gyc0sYIPbAmTgpbxl5dokjb8oPX1wM22z2EI,10969
 guppylang_internals/definition/overloaded.py,sha256=UQ64waMp48gEVDCqEzuJFrRoNJ9saUIRUAynF3T-Gz8,5132
-guppylang_internals/definition/parameter.py,sha256=dKAWQ6hQlqatXgcryiK27igxBsY5GrcB_9SucU2v4TE,2727
-guppylang_internals/definition/pytket_circuits.py,sha256=6zne7lrmP-vAYJfUtamRqsXcZEXwFzfFYxZelAeJQcs,18203
-guppylang_internals/definition/struct.py,sha256=zLAT75WgL6tzqxuRvscYCRnilngWOfOlfEnXEN-3jVo,15334
+guppylang_internals/definition/parameter.py,sha256=l60l-yO34gpeuKZ5D3ru8CS8wnQGuoAgqIUP1CrfOF8,2789
+guppylang_internals/definition/pytket_circuits.py,sha256=m_TlUATO7ijHv3O0Dm7FhbalRBufQ4sJ_kxRo500Bdo,16952
+guppylang_internals/definition/struct.py,sha256=YLFgCN9G2IufS2Z7X-nsUz6DxBMYa6MCtw-YwSAQniw,15534
 guppylang_internals/definition/traced.py,sha256=hMHnrLKdbMvmmzmcJRvOCR-WiPHJ3x5ji0am436HNTQ,5592
-guppylang_internals/definition/ty.py,sha256=Aw7kgDOGv3crRoESUlAeR_2ovX8kV0qhGhuHlGOLf1s,2081
+guppylang_internals/definition/ty.py,sha256=5Jt7twY8v1cE7noZ_RYfo0X55KYV6JI0itdHW9vvZs0,2085
 guppylang_internals/definition/value.py,sha256=tgkp-brIAauGXMqe68Fnwvz_bfdThdwJ_rzsGMbw95w,3452
 guppylang_internals/definition/wasm.py,sha256=Op8IpiKRZkNX-90UBp7uu3nCxx2VkbKKxHz-DZQuWs0,1987
 guppylang_internals/std/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -59,7 +61,7 @@ guppylang_internals/std/_internal/debug.py,sha256=hRgUM-35Mm0oZ1EPjr3RRTejaSD0Nb
 guppylang_internals/std/_internal/util.py,sha256=vkLUfIOwmRsjHbUmh-Gt4ykCUGZtQ2D6pLqpH-h-FbY,8299
 guppylang_internals/std/_internal/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/std/_internal/compiler/arithmetic.py,sha256=_Nf-P3GwTp-ZVLz62Hz9ModD74R41hKqutNGmp5Mn6g,4287
-guppylang_internals/std/_internal/compiler/array.py,sha256=bzL_CRDgXVLWYY6o02dHzrKrnNW3H62axHkpr1Q__wA,20819
+guppylang_internals/std/_internal/compiler/array.py,sha256=PepiCUthF0ebHF2eUUXSkRT_NPNS6gqqKiOhm0sv90c,13485
 guppylang_internals/std/_internal/compiler/either.py,sha256=LzLSfsafwVAgaeX8d91IRmrxK6kx0YC_MtGSBEgBsbs,4716
 guppylang_internals/std/_internal/compiler/frozenarray.py,sha256=BZMSSYTieqcFaAXGTR0nw2b7eN5LK2Et4vNZSBFRcyI,2361
 guppylang_internals/std/_internal/compiler/futures.py,sha256=nIaxXCGj4BPI_to_Q87gQEqN94Q8hb09ICkODZVOJrQ,1095
@@ -70,7 +72,7 @@ guppylang_internals/std/_internal/compiler/prelude.py,sha256=fwWWNDNUggFrtIG1JeQ
 guppylang_internals/std/_internal/compiler/qsystem.py,sha256=dKSpvpxF7WRfWuDj0u7zShEhTL6mkAr9pQNyYVoa8vM,1940
 guppylang_internals/std/_internal/compiler/quantum.py,sha256=gXuB1vpRl8ipgwwEYPCgoMPiqPUJ908Msl09jJFdWxg,3930
 guppylang_internals/std/_internal/compiler/tket_bool.py,sha256=ceO9BBF3HhjNAkc4dObJBH13Kpn08-pSaksjl3yoOa4,1207
-guppylang_internals/std/_internal/compiler/tket_exts.py,sha256=NteaIlCn4K0LoXwUCCLh39w7hoPdmpmdQ39_7P4ezKU,1381
+guppylang_internals/std/_internal/compiler/tket_exts.py,sha256=dvs9lgruCCvXno7aShwdLJs0dQHjjCxmPYODGEo66yU,1572
 guppylang_internals/std/_internal/compiler/wasm.py,sha256=1G8EzrnN3Yv12hIdv2XOg4Hq-QlvRYl7-4QbZYLYyM4,5727
 guppylang_internals/tracing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/tracing/builtins_mock.py,sha256=iKgrs626DVhdN7nJroKBLstWGwkr7PzJI4CrgqkMyTA,2963
@@ -78,21 +80,22 @@ guppylang_internals/tracing/frozenlist.py,sha256=sINk-PZTw4dNThF5GK9AZxAeX5ap-g_
 guppylang_internals/tracing/function.py,sha256=K2rEey0awOxwfljGk4uezRmXode7rgOKQY1VN94wOIo,7901
 guppylang_internals/tracing/object.py,sha256=WLALkgqCMXOmPOydb4Rkg7OxRweSke1f9YU_JohMaiE,19748
 guppylang_internals/tracing/state.py,sha256=J-fG0dZh9IeB6hpLfyp5IwqS2TW0Zr8XloMmuIHWS6Q,2083
-guppylang_internals/tracing/unpacking.py,sha256=i3qFl__DIdm8uuRfHNdisSLLxZ6hSe_8SFUTs8Bhv5Q,9075
+guppylang_internals/tracing/unpacking.py,sha256=6Df9h4pFS6mebyU3VR5DfO87Rs_QbTdSkLMNjpaM0Xc,8728
 guppylang_internals/tracing/util.py,sha256=zzVUeY7Ax4v_ZQh7QmckYaOWsg7BRZg6-oX4VWmytDU,3054
 guppylang_internals/tys/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-guppylang_internals/tys/arg.py,sha256=4mtfDHtybV8d6cpK-B_Sdc6FTIsVd2udJYvOGtepa3A,3892
-guppylang_internals/tys/builtin.py,sha256=iLhqxXM4v66erI22-k__Xc_86ANw9_d7acUyrLq-yMM,12763
+guppylang_internals/tys/arg.py,sha256=zrZm_6TnXS-tFvk5xRk40ayu8z99OQ_35L9oMp6hGNM,4417
+guppylang_internals/tys/builtin.py,sha256=9QY_ayWxiwWkeTC2erIicbq4ZMbzETw0PbIl8hBu0XQ,12544
 guppylang_internals/tys/common.py,sha256=kCJDzSquUdztV5zEINE0Lxigawux9te0lmzd0Oa70J0,3575
-guppylang_internals/tys/const.py,sha256=MiD46lybIqkiXEh_7ekipYanIe7MahDwY8c-PWY0s3c,3718
+guppylang_internals/tys/const.py,sha256=kl15uOriJFLUpoodb75f4dl3HYYa6OuKWA2B0vheVPY,4876
 guppylang_internals/tys/errors.py,sha256=Llc1CXDqkXW6Hi-cpMJaTLKweSN2a2E4sHpXapC0VRA,5514
-guppylang_internals/tys/param.py,sha256=9GsfJ4Hjt4FkjgC4lFirUjE7oVkqTD-ACV0LJWstswI,9340
-guppylang_internals/tys/parsing.py,sha256=A7zwXvXLFze8wtxI0Am1VqG98ddgGw7vqevo_29qCoQ,16863
+guppylang_internals/tys/param.py,sha256=NXNDp8yrxbCkCo6oWCnjGg1ZoJ-F0leR5aUIj2eZQrc,10165
+guppylang_internals/tys/parsing.py,sha256=Dn7VPvmbjAHCXlC54TiUYDvDZA4HNkqabscm44wMi3c,15956
 guppylang_internals/tys/printing.py,sha256=F60SZsvqDRNMQSbgNDfBDt2pYQH2ueaZo7ObmUa2fLE,5961
-guppylang_internals/tys/subst.py,sha256=REFbw2POB6wGw-NBOZ4K4T6gE5FZe6nQ_VjcUmhOxCs,3430
-guppylang_internals/tys/ty.py,sha256=ejvC8fg-BpaCf0Cs9sZIBjaKW2yQwapOG_KbThCkoKg,30973
+guppylang_internals/tys/qubit.py,sha256=Mp1hW9fMBtzrN2U7BTYUmH-FzFw08EUMIcSYZFCsK30,820
+guppylang_internals/tys/subst.py,sha256=fMIh7jNMMNiKjlr3WMxAwY_ovX1qTaz_c5foruYkLPs,3049
+guppylang_internals/tys/ty.py,sha256=AKoiEXH35ZQooKA5LDT6zzoV4uDRaNFOHBN0JJjtn2g,31110
 guppylang_internals/tys/var.py,sha256=zACXv2IvGrqjDryC6lMyZpNnDb3SBRM2SlTOyq6WJdo,1173
-guppylang_internals-0.24.0.dist-info/METADATA,sha256=FN7OX-_6P1uO-j0DFz0aTf4Y56RV4pOAuwNQvNRSzFc,14808
-guppylang_internals-0.24.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-guppylang_internals-0.24.0.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-guppylang_internals-0.24.0.dist-info/RECORD,,
+guppylang_internals-0.25.0.dist-info/METADATA,sha256=4BWfyYCyPcZwe3SzpNToowtCNtH498OMi-Kxx-MNQ7w,14808
+guppylang_internals-0.25.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+guppylang_internals-0.25.0.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+guppylang_internals-0.25.0.dist-info/RECORD,,