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

guppylang_internals/tys/printing.py

@@ -11,7 +11,6 @@ from guppylang_internals.tys.ty import (
     NumericType,
     OpaqueType,
     StructType,
-    SumType,
     TupleType,
     Type,
 )
@@ -122,11 +121,6 @@ class TypePrinter:
         args = ", ".join(self._visit(arg, True) for arg in ty.args)
         return f"({args})"
 
-    @_visit.register
-    def _visit_SumType(self, ty: SumType, inside_row: bool) -> str:
-        args = ", ".join(self._visit(arg, True) for arg in ty.args)
-        return f"Sum[{args}]"
-
     @_visit.register
     def _visit_NoneType(self, ty: NoneType, inside_row: bool) -> str:
         return "None"
@@ -168,7 +162,7 @@ def signature_to_str(name: str, sig: FunctionType) -> str:
     assert sig.input_names is not None
     s = f"def {name}("
     s += ", ".join(
-        f"{name}: {inp.ty}{TypePrinter._print_flags(inp.flags)}"
-        for name, inp in zip(sig.input_names, sig.inputs, strict=True)
+        f"{inp.name}: {inp.ty}{TypePrinter._print_flags(inp.flags)}"
+        for inp in sig.inputs
     )
     return s + ") -> " + str(sig.output)

guppylang_internals/tys/qubit.py

@@ -1,8 +1,10 @@
 import functools
-from typing import cast
+from typing import Any, cast
 
 from guppylang_internals.definition.ty import TypeDef
-from guppylang_internals.tys.ty import Type
+from guppylang_internals.tys.arg import TypeArg
+from guppylang_internals.tys.common import Visitor
+from guppylang_internals.tys.ty import OpaqueType, Type
 
 
 @functools.cache
@@ -25,3 +27,36 @@ def is_qubit_ty(ty: Type) -> bool:
     before qubit types are registered.
     """
     return ty == qubit_ty()
+
+
+class QubitFinder(Visitor):
+    """Type visitor that checks if a type contains the qubit type."""
+
+    class FoundFlag(Exception):
+        pass
+
+    @functools.singledispatchmethod
+    def visit(self, ty: Any) -> bool:  # type: ignore[override]
+        return False
+
+    @visit.register
+    def _visit_OpaqueType(self, ty: OpaqueType) -> bool:
+        if is_qubit_ty(ty):
+            raise self.FoundFlag
+        return False
+
+    @visit.register
+    def _visit_TypeArg(self, arg: TypeArg) -> bool:
+        arg.ty.visit(self)
+        return True
+
+
+def contain_qubit_ty(ty: Type) -> bool:
+    """Checks if the given type contains the qubit type."""
+    finder = QubitFinder()
+    try:
+        ty.visit(finder)
+    except QubitFinder.FoundFlag:
+        return True
+    else:
+        return False

guppylang_internals/tys/ty.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 enum import Enum, Flag, auto
 from functools import cached_property, total_ordering
 from typing import TYPE_CHECKING, ClassVar, TypeAlias, cast
@@ -369,6 +369,21 @@ class InputFlags(Flag):
     Comptime = auto()
 
 
+class UnitaryFlags(Flag):
+    """Flags that can be set on functions to indicate their unitary properties.
+
+    The flags indicate under which conditions a function can be used
+    in a unitary context.
+    """
+
+    NoFlags = 0
+    Control = auto()
+    Dagger = auto()
+    Power = auto()
+
+    Unitary = Control | Dagger | Power
+
+
 @dataclass(frozen=True)
 class FuncInput:
     """A single input of a function type."""
@@ -376,6 +391,10 @@ class FuncInput:
     ty: "Type"
     flags: InputFlags
 
+    #: Name of this input, or `None` if it is an unnamed argument (e.g. inside a
+    #: `Callable`). We use `compare=False` because names are not visible to the caller.
+    name: str | None = field(default=None, compare=False)
+
 
 @dataclass(frozen=True, init=False)
 class FunctionType(ParametrizedTypeBase):
@@ -384,7 +403,6 @@ class FunctionType(ParametrizedTypeBase):
     inputs: Sequence[FuncInput]
     output: "Type"
     params: Sequence[Parameter]
-    input_names: Sequence[str] | None
     comptime_args: Sequence[ConstArg]
 
     args: Sequence[Argument] = field(init=False)
@@ -394,13 +412,15 @@ class FunctionType(ParametrizedTypeBase):
     intrinsically_droppable: bool = field(default=True, init=True)
     hugr_bound: ht.TypeBound = field(default=ht.TypeBound.Copyable, init=False)
 
+    unitary_flags: UnitaryFlags = field(default=UnitaryFlags.NoFlags, init=True)
+
     def __init__(
         self,
         inputs: Sequence[FuncInput],
         output: "Type",
-        input_names: Sequence[str] | None = None,
         params: Sequence[Parameter] | None = None,
         comptime_args: Sequence[ConstArg] | None = None,
+        unitary_flags: UnitaryFlags = UnitaryFlags.NoFlags,
     ) -> None:
         # We need a custom __init__ to set the args
         args: list[Argument] = [TypeArg(inp.ty) for inp in inputs]
@@ -416,12 +436,19 @@ class FunctionType(ParametrizedTypeBase):
             ]
         args += comptime_args
 
+        # Either all inputs must have unique names, or none of them have names
+        names = {inp.name for inp in inputs if inp.name is not None}
+        if len(names) not in (0, len(inputs)):
+            raise InternalGuppyError(
+                "Tried to construct FunctionType with invalid input names"
+            )
+
         object.__setattr__(self, "args", args)
         object.__setattr__(self, "comptime_args", comptime_args)
         object.__setattr__(self, "inputs", inputs)
         object.__setattr__(self, "output", output)
-        object.__setattr__(self, "input_names", input_names or [])
         object.__setattr__(self, "params", params)
+        object.__setattr__(self, "unitary_flags", unitary_flags)
 
     @property
     def parametrized(self) -> bool:
@@ -436,6 +463,16 @@ class FunctionType(ParametrizedTypeBase):
             return set()
         return super().bound_vars
 
+    @cached_property
+    def input_names(self) -> Sequence[str] | None:
+        """Names of all inputs or `None` if there are unnamed inputs."""
+        names: list[str] = []
+        for inp in self.inputs:
+            if inp.name is None:
+                return None
+            names.append(inp.name)
+        return names
+
     def cast(self) -> "Type":
         """Casts an implementor of `TypeBase` into a `Type`."""
         return self
@@ -494,12 +531,8 @@ class FunctionType(ParametrizedTypeBase):
     def transform(self, transformer: Transformer) -> "Type":
         """Accepts a transformer on this type."""
         return transformer.transform(self) or FunctionType(
-            [
-                FuncInput(inp.ty.transform(transformer), inp.flags)
-                for inp in self.inputs
-            ],
+            [replace(inp, ty=inp.ty.transform(transformer)) for inp in self.inputs],
             self.output.transform(transformer),
-            self.input_names,
             self.params,
         )
 
@@ -529,9 +562,8 @@ class FunctionType(ParametrizedTypeBase):
 
         inst = Instantiator(full_inst)
         return FunctionType(
-            [FuncInput(inp.ty.transform(inst), inp.flags) for inp in self.inputs],
+            [replace(inp, ty=inp.ty.transform(inst)) for inp in self.inputs],
             self.output.transform(inst),
-            self.input_names,
             remaining_params,
             # Comptime type arguments also need to be instantiated
             comptime_args=[
@@ -548,6 +580,18 @@ class FunctionType(ParametrizedTypeBase):
         exs = [param.to_existential() for param in self.params]
         return self.instantiate([arg for arg, _ in exs]), [var for _, var in exs]
 
+    def with_unitary_flags(self, flags: UnitaryFlags) -> "FunctionType":
+        """Returns a copy of this function type with the specified unitary flags."""
+        # N.B. we can't use `dataclasses.replace` here since `FunctionType` has a custom
+        # constructor
+        return FunctionType(
+            self.inputs,
+            self.output,
+            self.params,
+            self.comptime_args,
+            flags,
+        )
+
 
 @dataclass(frozen=True, init=False)
 class TupleType(ParametrizedTypeBase):
@@ -592,53 +636,6 @@ class TupleType(ParametrizedTypeBase):
         )
 
 
-@dataclass(frozen=True, init=False)
-class SumType(ParametrizedTypeBase):
-    """Type of sums.
-
-    Note that this type is only used internally when constructing the Hugr. Users cannot
-    write down this type.
-    """
-
-    element_types: Sequence["Type"]
-
-    def __init__(self, element_types: Sequence["Type"]) -> None:
-        # We need a custom __init__ to set the args
-        args = [TypeArg(ty) for ty in element_types]
-        object.__setattr__(self, "args", args)
-        object.__setattr__(self, "element_types", element_types)
-
-    @property
-    def intrinsically_copyable(self) -> bool:
-        """Whether objects of this type can be implicitly copied."""
-        return True
-
-    @property
-    def intrinsically_droppable(self) -> bool:
-        """Whether objects of this type can be dropped."""
-        return True
-
-    def cast(self) -> "Type":
-        """Casts an implementor of `TypeBase` into a `Type`."""
-        return self
-
-    def to_hugr(self, ctx: ToHugrContext) -> ht.Sum:
-        """Computes the Hugr representation of the type."""
-        rows = [type_to_row(ty) for ty in self.element_types]
-        if all(len(row) == 0 for row in rows):
-            return ht.UnitSum(size=len(rows))
-        elif len(rows) == 1:
-            return ht.Tuple(*row_to_hugr(rows[0], ctx))
-        else:
-            return ht.Sum(variant_rows=rows_to_hugr(rows, ctx))
-
-    def transform(self, transformer: Transformer) -> "Type":
-        """Accepts a transformer on this type."""
-        return transformer.transform(self) or SumType(
-            [ty.transform(transformer) for ty in self.element_types]
-        )
-
-
 @dataclass(frozen=True)
 class OpaqueType(ParametrizedTypeBase):
     """Type that is directly backed by a Hugr opaque type.
@@ -727,9 +724,8 @@ class StructType(ParametrizedTypeBase):
 
 
 #: The type of parametrized Guppy types.
-ParametrizedType: TypeAlias = (
-    FunctionType | TupleType | SumType | OpaqueType | StructType
-)
+ParametrizedType: TypeAlias = FunctionType | TupleType | OpaqueType | StructType
+
 
 #: The type of Guppy types.
 #:
@@ -811,8 +807,6 @@ def unify(s: Type | Const, t: Type | Const, subst: "Subst | None") -> "Subst | N
             return _unify_args(s, t, subst)
         case TupleType() as s, TupleType() as t:
             return _unify_args(s, t, subst)
-        case SumType() as s, SumType() as t:
-            return _unify_args(s, t, subst)
         case OpaqueType() as s, OpaqueType() as t if s.defn == t.defn:
             return _unify_args(s, t, subst)
         case StructType() as s, StructType() as t if s.defn == t.defn:
@@ -881,6 +875,8 @@ def function_tensor_signature(tys: list[FunctionType]) -> FunctionType:
     outputs: list[Type] = []
     for fun_ty in tys:
         assert not fun_ty.parametrized
-        inputs.extend(fun_ty.inputs)
+        # Forget the function input names since they might be non-unique across the
+        # tensored functions
+        inputs.extend([replace(inp, name=None) for inp in fun_ty.inputs])
         outputs.extend(type_to_row(fun_ty.output))
     return FunctionType(inputs, row_to_type(outputs))

guppylang_internals/wasm_util.py

@@ -0,0 +1,129 @@
+from dataclasses import dataclass
+from typing import ClassVar
+
+import wasmtime as wt
+
+from guppylang_internals.diagnostic import Error, Note
+from guppylang_internals.tys.ty import (
+    FuncInput,
+    FunctionType,
+    InputFlags,
+    NoneType,
+    NumericType,
+    Type,
+)
+
+
+# The thing to be imported elsewhere
+@dataclass
+class ConcreteWasmModule:
+    filename: str
+    # Function names in order for looking up by index
+    functions: list[str]
+    function_sigs: dict[str, FunctionType | str]
+
+
+@dataclass(frozen=True)
+class WasmSignatureError(Error):
+    title: ClassVar[str] = (
+        "Invalid signature for @wasm function `{fn_name}`\n"
+        "in wasm file: `{filename}`"
+    )
+    fn_name: str
+    filename: str
+
+    @dataclass(frozen=True)
+    class Message(Note):
+        message = "{msg}"
+        msg: str
+
+
+@dataclass(frozen=True)
+class WasmFileNotFound(Error):
+    title: ClassVar[str] = "Wasm file `{file}` not found"
+    file: str
+
+
+@dataclass(frozen=True)
+class WasmFunctionNotInFile(Error):
+    title: ClassVar[str] = (
+        "Declared wasm function `{function}` isn't exported by wasm file"
+    )
+    function: str
+
+    @dataclass(frozen=True)
+    class WasmFileNote(Note):
+        message: ClassVar[str] = "Wasm file: {filename}"
+        filename: str
+
+
+@dataclass(frozen=True)
+class WasmSigMismatchError(Error):
+    title: ClassVar[str] = "Wasm signature mismatch"
+    span_label: ClassVar[str] = (
+        "Signature of wasm function didn't match that in provided wasm file"
+    )
+
+    @dataclass(frozen=True)
+    class Declaration(Note):
+        message: ClassVar[str] = "Declared signature: {declared}"
+        declared: str
+
+    @dataclass(frozen=True)
+    class Actual(Note):
+        message: ClassVar[str] = "Signature in wasm:  {actual}"
+        actual: str
+
+
+def decode_type(ty: wt.ValType) -> Type | None:
+    if ty == wt.ValType.i64():
+        return NumericType(NumericType.Kind.Int)
+    elif ty == wt.ValType.f64():
+        return NumericType(NumericType.Kind.Float)
+    else:
+        return None
+
+
+def decode_sig(
+    params: list[wt.ValType], output: wt.ValType | None
+) -> FunctionType | str:
+    # Function args in wasm are called "params"
+    my_params: list[FuncInput] = []
+    for p in params:
+        if ty := decode_type(p):
+            my_params.append(FuncInput(ty, flags=InputFlags.NoFlags))
+        else:
+            return f"Unsupported input type: {p}"
+    if output:
+        if ty := decode_type(output):
+            return FunctionType(my_params, ty)
+        else:
+            return f"Unsupported output type: {output}"
+    else:
+        return FunctionType(my_params, NoneType())
+
+
+def decode_wasm_functions(filename: str) -> ConcreteWasmModule:
+    engine = wt.Engine()
+    mod = wt.Module.from_file(engine, filename)
+
+    functions: list[str] = []
+    function_sigs: dict[str, FunctionType | str] = {}
+    for fn in mod.exports:
+        functions.append(fn.name)
+        match fn.type:
+            case wt.FuncType() as fun_ty:
+                match fun_ty.results:
+                    case []:
+                        data = decode_sig(fun_ty.params, None)
+                    case [output]:
+                        data = decode_sig(fun_ty.params, output)
+                    case _multi:
+                        data = (
+                            f"Multiple output types unsupported in function `{fn.name}`"
+                        )
+            case _:
+                data = f"`{fn.name}` is not exported as a function"
+        function_sigs[fn.name] = data
+
+    return ConcreteWasmModule(filename, functions, function_sigs)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guppylang-internals
-Version: 0.25.0
+Version: 0.26.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>
@@ -222,6 +222,7 @@ Requires-Python: <4,>=3.10
 Requires-Dist: hugr~=0.14.1
 Requires-Dist: tket-exts~=0.12.0
 Requires-Dist: typing-extensions<5,>=4.9.0
+Requires-Dist: wasmtime~=v38.0.0
 Provides-Extra: pytket
 Requires-Dist: pytket>=1.34; extra == 'pytket'
 Description-Content-Type: text/markdown
@@ -244,10 +245,10 @@ pip install guppylang-internals
 
 See [DEVELOPMENT.md] information on how to develop and contribute to this package.
 
-  [DEVELOPMENT.md]: https://github.com/CQCL/guppylang/blob/main/DEVELOPMENT.md
+  [DEVELOPMENT.md]: https://github.com/quantinuum/guppylang/blob/main/DEVELOPMENT.md
 
 ## License
 
 This project is licensed under Apache License, Version 2.0 ([LICENCE][] or http://www.apache.org/licenses/LICENSE-2.0).
 
-  [LICENCE]: https://github.com/CQCL/guppylang/blob/main/LICENCE
+  [LICENCE]: https://github.com/quantinuum/guppylang/blob/main/LICENCE

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

@@ -1,84 +1,87 @@
-guppylang_internals/__init__.py,sha256=EgbPDr6Utan7jHefvmK8YWd_y5KDx9mb6kOXetg5X_4,130
+guppylang_internals/__init__.py,sha256=eRNAncl2ENPaWe98y6nNX-U9UtENwgo-yfbWQkZy8Cs,130
 guppylang_internals/ast_util.py,sha256=WHa7axpGrdsjzQk3iw3reDzYlcmsx0HsNH4Qbqwjjig,12531
-guppylang_internals/decorator.py,sha256=AWfPMMXzq5YC8nfB6DOwnRsrWKztuUK19n8APllgQ2w,10928
+guppylang_internals/decorator.py,sha256=i0PV3XzWBFjBUBSGfq7d4KmQuEwvM3bAsatcTXVZq98,14112
 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/engine.py,sha256=Npp02xXTb6bFYmHw52LVsVCAUi6dT3qaItEmpCB_2uA,10889
 guppylang_internals/error.py,sha256=fjHsbglnH9GtcsLF4sSry7FTjrLoiyQ-L1JS3uGirx0,3393
 guppylang_internals/experimental.py,sha256=yERQgpT7P-x0-nr4gU4PdUCntByQwF2I9rfjpWtgqn4,3115
 guppylang_internals/ipython_inspect.py,sha256=rY2DpSpSBrRk0IZmuoz7jh35kGZHQnHLAQQFdb_-WnI,931
-guppylang_internals/nodes.py,sha256=rJMtAJL_eRnrI6MZkweAWs1gYteCP3HSZM9BEkyAW7Q,12803
+guppylang_internals/nodes.py,sha256=wnnAI3sHZ-OwolcZMKYA_dkmz4IE5Y4CFqXDJ0LXAJM,12824
 guppylang_internals/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/span.py,sha256=8rWzAAipWunhhyCp44qdUAPmOfAXkEMvicK0PYc3tTg,4986
+guppylang_internals/wasm_util.py,sha256=TyTS9pbFlqpcjCnRwCdCQliGhUWVHkUcZswAytI8oNc,3590
 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=TxV5yHRqiH86lvLR0g4EZ4fs7S6Axoof1l0TIAZArJM,8591
-guppylang_internals/cfg/builder.py,sha256=UJXLzCNEA8nKCrRV3Y2AhMVwncbiHFD5m4t8zIKD5Ag,27630
-guppylang_internals/cfg/cfg.py,sha256=G6wTHtyRYcBN7FIwyIQnt3akVjM-Rl37PEXAaujplMg,4355
+guppylang_internals/cfg/builder.py,sha256=QqzleSd5-3h77Uy-ng_lNJz73C6-eGwgG_6my8Dh2pQ,28252
+guppylang_internals/cfg/cfg.py,sha256=qQuWGK1rgPIkMyJFsX3LrqnXp3ptDDOuXwTbgf_NUSE,4489
 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=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/cfg_checker.py,sha256=0hDxw2CTbTbjewtDjaoBehgon17tJaQG9YPO_qR6P0Q,13667
+guppylang_internals/checker/core.py,sha256=IPgnaRih5flDevzJsu6o_ycG3vk2X9Mt4A-MZ7gufNU,18163
+guppylang_internals/checker/expr_checker.py,sha256=cQVigPN-BE-0nfo_8EUSxCgzSFFfRTxA3dvEMZzzGA8,60121
+guppylang_internals/checker/func_checker.py,sha256=WxQtwQdYOfvPVHRem__LoBMax5eUzvmqEJXbxmHzG5M,16118
+guppylang_internals/checker/linearity_checker.py,sha256=cVgoUshu6YPEJ2mgk3RUWx38qt52WNMxjyLVV5eqgD4,37160
+guppylang_internals/checker/modifier_checker.py,sha256=ruhEkbT4g9YIJXOGRsfpdzUsbXxEbS95PC1LG-EAl3o,4175
 guppylang_internals/checker/stmt_checker.py,sha256=paUBaAwx3QRpJAonND8wBpO4FxcNb4iPXMzImB11T9A,20785
+guppylang_internals/checker/unitary_checker.py,sha256=TVUT4JskaOzNVLcMrQwOd5t5MBLdHC2jFEtFHzlOW8I,4512
 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=r-BiSrmJh9jfXlxE029GMQ8yj30_qOTW2RAQsd3HYzs,2050
 guppylang_internals/checker/errors/linearity.py,sha256=VLGvwzfW6uljNjYUEIxNkgt6s3q9-yo1O22BoTiS4Xs,8922
 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/checker/errors/wasm.py,sha256=TlwQRtlA0zpu8xwkBHWPYc25OIb6NrMHRxuYUfyD0Rg,956
 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=mw7mQXQoBrt28NxjQ-3JSKhYVyVsDC21YVDaAaDtWBo,31518
-guppylang_internals/compiler/expr_compiler.py,sha256=Km9ne1yd6A9ykpZvNMtZyktPagjJCHoZWEpx2M8i7gY,38600
+guppylang_internals/compiler/cfg_compiler.py,sha256=dKAh2dWMUCXHpb5GjRzgT6Npnv74Vx5WqMaaa_X1koI,9004
+guppylang_internals/compiler/core.py,sha256=iWD2K4Ztu1nvK6o5ZIyR_c3UBc4cjBxfgzrZEJuOdfY,31548
+guppylang_internals/compiler/expr_compiler.py,sha256=ZlOP4JnvggjXC3uf0km-nRzk04IbblEdEJLeZpIWFDI,37198
 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/modifier_compiler.py,sha256=Ni0ANon4kI8Ro3YIh_jt1-7Ucs12KmWmE7QDq_MDMgw,6464
 guppylang_internals/compiler/qtm_platform_extension.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=V3KU92rIonEdWyCwt3Rfkblic-XH-V0moGCTws3Sgbc,19539
-guppylang_internals/definition/declaration.py,sha256=rmZdYHTTxjALfWmEfoNMVQ9hBmeV3o3VNXm9gcs3ubc,5883
+guppylang_internals/definition/custom.py,sha256=sPYY8o1_WuSNHQazV4KCvUcLer8mvepTYb285XMGkEM,19683
+guppylang_internals/definition/declaration.py,sha256=vwo7P6D3TJU_6wfTWmx6KnmjOCCGLiGjJQ-Zf_02rYM,6038
 guppylang_internals/definition/extern.py,sha256=hEajRYaapKIfX9J7scnusQHc1e_bCxB4oUVWZ-D4c8o,2878
-guppylang_internals/definition/function.py,sha256=oz-4dk5gyc0sYIPbAmTgpbxl5dokjb8oPX1wM22z2EI,10969
+guppylang_internals/definition/function.py,sha256=LPWvQrlzTnY_18n_myD063p7KdXM51CJIIjmpdBTStY,11395
 guppylang_internals/definition/overloaded.py,sha256=UQ64waMp48gEVDCqEzuJFrRoNJ9saUIRUAynF3T-Gz8,5132
 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/pytket_circuits.py,sha256=SkOUg3EwBjpeb3_2PzvkH9xzAvI_OIt-wILY37wv2zI,17010
+guppylang_internals/definition/struct.py,sha256=Jed5kcoc57toQr4f7zeB7mr6fSDP1Q2KRnmGJvbVXF4,15572
 guppylang_internals/definition/traced.py,sha256=hMHnrLKdbMvmmzmcJRvOCR-WiPHJ3x5ji0am436HNTQ,5592
 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/definition/wasm.py,sha256=iGxVdKIXYdfODLEvPg7fefE5lLWbQ3bWPIc6dAxnqWw,3389
 guppylang_internals/std/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/std/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-guppylang_internals/std/_internal/checker.py,sha256=26GgGr2bBu6CAeWiYh-ggCz5rjOuL_ZJgbq1KwpZE4k,21731
+guppylang_internals/std/_internal/checker.py,sha256=aFtfGxeJd2UypQs1otbK93Wq_rIEOiimSP4JqgB559I,18037
 guppylang_internals/std/_internal/compiler.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-guppylang_internals/std/_internal/debug.py,sha256=hRgUM-35Mm0oZ1EPjr3RRTejaSD0Nb8wDF2e0RXpq9M,3615
-guppylang_internals/std/_internal/util.py,sha256=vkLUfIOwmRsjHbUmh-Gt4ykCUGZtQ2D6pLqpH-h-FbY,8299
+guppylang_internals/std/_internal/debug.py,sha256=j6bGg9TFn4fR8-H8Hk10BfY9EkanfiJn5ArLeBMISZo,3894
+guppylang_internals/std/_internal/util.py,sha256=e_sawDuuk1YFpbEQXbpAvWMNeTlkGb4P0t6Ed0JpP9M,8305
 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=PepiCUthF0ebHF2eUUXSkRT_NPNS6gqqKiOhm0sv90c,13485
+guppylang_internals/std/_internal/compiler/array.py,sha256=YTFzInN7DkU4M_AASHR__D_9bouvaNrYNRKxsO3-Fek,13491
 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
-guppylang_internals/std/_internal/compiler/list.py,sha256=D8SfpHpvCJM_wZIUAMCAj6BWoMi_ah6mI_yG_cDZa-w,12568
+guppylang_internals/std/_internal/compiler/list.py,sha256=Tqvs-J7iL5TxG5qgk-dboXU3-y7uZq-tQ9r9xFhmw4c,12574
 guppylang_internals/std/_internal/compiler/mem.py,sha256=hiPFzZYAne9b0Si8JXIzLuXhqvv20kDtIjG7m-jRA8U,516
 guppylang_internals/std/_internal/compiler/option.py,sha256=no0KlvQFLNmXXOPzdqede-TeuYzkFTrmh_CPrAxKZ1c,2621
-guppylang_internals/std/_internal/compiler/prelude.py,sha256=fwWWNDNUggFrtIG1JeQQM4_R905jMHrX551MOxOaKT8,9318
+guppylang_internals/std/_internal/compiler/platform.py,sha256=3TMYdRO--Sabapo4K0T_AfG1OMUYRDaltrNHJb4hXvg,6161
+guppylang_internals/std/_internal/compiler/prelude.py,sha256=2pOmi1JNBHsETkC4EGskbFBAZAlAJ4IvWZLe5v4DIFM,9635
 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=dvs9lgruCCvXno7aShwdLJs0dQHjjCxmPYODGEo66yU,1572
+guppylang_internals/std/_internal/compiler/tket_exts.py,sha256=E7Ywu6xiMepkFoNYZ90rBMPLi3l1MlZSTJE0YmO6TAo,1540
 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
 guppylang_internals/tracing/frozenlist.py,sha256=sINk-PZTw4dNThF5GK9AZxAeX5ap-g_hbqxZ79GtLAc,1823
 guppylang_internals/tracing/function.py,sha256=K2rEey0awOxwfljGk4uezRmXode7rgOKQY1VN94wOIo,7901
-guppylang_internals/tracing/object.py,sha256=WLALkgqCMXOmPOydb4Rkg7OxRweSke1f9YU_JohMaiE,19748
+guppylang_internals/tracing/object.py,sha256=UMysud9Cc4pHqIDF2qn0zwo97q5d1IqMn1CHxvcitBs,20393
 guppylang_internals/tracing/state.py,sha256=J-fG0dZh9IeB6hpLfyp5IwqS2TW0Zr8XloMmuIHWS6Q,2083
 guppylang_internals/tracing/unpacking.py,sha256=6Df9h4pFS6mebyU3VR5DfO87Rs_QbTdSkLMNjpaM0Xc,8728
 guppylang_internals/tracing/util.py,sha256=zzVUeY7Ax4v_ZQh7QmckYaOWsg7BRZg6-oX4VWmytDU,3054
@@ -87,15 +90,15 @@ guppylang_internals/tys/arg.py,sha256=zrZm_6TnXS-tFvk5xRk40ayu8z99OQ_35L9oMp6hGN
 guppylang_internals/tys/builtin.py,sha256=9QY_ayWxiwWkeTC2erIicbq4ZMbzETw0PbIl8hBu0XQ,12544
 guppylang_internals/tys/common.py,sha256=kCJDzSquUdztV5zEINE0Lxigawux9te0lmzd0Oa70J0,3575
 guppylang_internals/tys/const.py,sha256=kl15uOriJFLUpoodb75f4dl3HYYa6OuKWA2B0vheVPY,4876
-guppylang_internals/tys/errors.py,sha256=Llc1CXDqkXW6Hi-cpMJaTLKweSN2a2E4sHpXapC0VRA,5514
+guppylang_internals/tys/errors.py,sha256=zg3R-R-W5D-5kAm_xEemvfs4GJ7NHLgAL_N2WToquZA,6158
 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/qubit.py,sha256=Mp1hW9fMBtzrN2U7BTYUmH-FzFw08EUMIcSYZFCsK30,820
+guppylang_internals/tys/parsing.py,sha256=w2uHVcGXU6ekMQZSPX0je9gSavigh3GIyIr8jvq2oSg,15974
+guppylang_internals/tys/printing.py,sha256=4DewINiHYMI_l_hmhDhfUYiWmfdj2s2NkKZcMC4Qu7U,5723
+guppylang_internals/tys/qubit.py,sha256=Y7RRc3_bP9LIoAMqjDsVNVzaplgF7h26L2OJB5XpDVc,1732
 guppylang_internals/tys/subst.py,sha256=fMIh7jNMMNiKjlr3WMxAwY_ovX1qTaz_c5foruYkLPs,3049
-guppylang_internals/tys/ty.py,sha256=AKoiEXH35ZQooKA5LDT6zzoV4uDRaNFOHBN0JJjtn2g,31110
+guppylang_internals/tys/ty.py,sha256=kRkI_QfPbITKuHre29Ejha55Y68j-aiLAWSBdvO1Ma8,31115
 guppylang_internals/tys/var.py,sha256=zACXv2IvGrqjDryC6lMyZpNnDb3SBRM2SlTOyq6WJdo,1173
-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,,
+guppylang_internals-0.26.0.dist-info/METADATA,sha256=yTv-p1nskM4Z4zIz0laFimpTCmF5bYPq6NxG_t_h8PY,14853
+guppylang_internals-0.26.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+guppylang_internals-0.26.0.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+guppylang_internals-0.26.0.dist-info/RECORD,,

{guppylang_internals-0.25.0.dist-info → guppylang_internals-0.26.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any