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

guppylang_internals/tys/parsing.py

@@ -1,6 +1,7 @@
 import ast
 import sys
 from collections.abc import Sequence
+from dataclasses import dataclass, field
 from types import ModuleType
 
 from guppylang_internals.ast_util import (
@@ -17,7 +18,7 @@ from guppylang_internals.definition.ty import TypeDef
 from guppylang_internals.engine import ENGINE
 from guppylang_internals.error import GuppyError
 from guppylang_internals.tys.arg import Argument, ConstArg, TypeArg
-from guppylang_internals.tys.builtin import CallableTypeDef, bool_type
+from guppylang_internals.tys.builtin import CallableTypeDef, SelfTypeDef, bool_type
 from guppylang_internals.tys.const import ConstValue
 from guppylang_internals.tys.errors import (
     CallableComptimeError,
@@ -34,6 +35,8 @@ from guppylang_internals.tys.errors import (
     LinearConstParamError,
     ModuleMemberNotFoundError,
     NonLinearOwnedError,
+    SelfTyNotInMethodError,
+    WrongNumberOfTypeArgsError,
 )
 from guppylang_internals.tys.param import ConstParam, Parameter, TypeParam
 from guppylang_internals.tys.subst import BoundVarFinder
@@ -48,46 +51,51 @@ from guppylang_internals.tys.ty import (
 )
 
 
-def arg_from_ast(
-    node: AstNode,
-    globals: Globals,
-    param_var_mapping: dict[str, Parameter],
-    allow_free_vars: bool = False,
-) -> Argument:
+@dataclass(frozen=True)
+class TypeParsingCtx:
+    """Context for parsing types from AST nodes."""
+
+    #: The globals variable context
+    globals: Globals
+
+    #: The available type parameters indexed by name
+    param_var_mapping: dict[str, Parameter] = field(default_factory=dict)
+
+    #: Whether a previously unseen type parameters is allowed to be bound (i.e. is
+    #: allowed to be added to `param_var_mapping`
+    allow_free_vars: bool = False
+
+    #: When parsing types in the signature or body of a method, we also need access to
+    #: the type this method belongs to in order to resolve `Self` annotations.
+    self_ty: Type | None = None
+
+
+def arg_from_ast(node: AstNode, ctx: TypeParsingCtx) -> Argument:
     """Turns an AST expression into an argument."""
     from guppylang_internals.checker.cfg_checker import VarNotDefinedError
 
     # A single (possibly qualified) identifier
-    if defn := _try_parse_defn(node, globals):
-        return _arg_from_instantiated_defn(
-            defn, [], globals, node, param_var_mapping, allow_free_vars
-        )
+    if defn := _try_parse_defn(node, ctx.globals):
+        return _arg_from_instantiated_defn(defn, [], node, ctx)
 
     # An identifier referring to a quantified variable
     if isinstance(node, ast.Name):
-        if node.id in param_var_mapping:
-            return param_var_mapping[node.id].to_bound()
+        if node.id in ctx.param_var_mapping:
+            return ctx.param_var_mapping[node.id].to_bound()
         raise GuppyError(VarNotDefinedError(node, node.id))
 
     # A parametrised type, e.g. `list[??]`
     if isinstance(node, ast.Subscript) and (
-        defn := _try_parse_defn(node.value, globals)
+        defn := _try_parse_defn(node.value, ctx.globals)
     ):
         arg_nodes = (
             node.slice.elts if isinstance(node.slice, ast.Tuple) else [node.slice]
         )
-        return _arg_from_instantiated_defn(
-            defn, arg_nodes, globals, node, param_var_mapping, allow_free_vars
-        )
+        return _arg_from_instantiated_defn(defn, arg_nodes, node, ctx)
 
     # We allow tuple types to be written as `(int, bool)`
     if isinstance(node, ast.Tuple):
-        ty = TupleType(
-            [
-                type_from_ast(el, globals, param_var_mapping, allow_free_vars)
-                for el in node.elts
-            ]
-        )
+        ty = TupleType([type_from_ast(el, ctx) for el in node.elts])
         return TypeArg(ty)
 
     # Literals
@@ -118,7 +126,7 @@ def arg_from_ast(
     if comptime_expr := is_comptime_expression(node):
         from guppylang_internals.checker.expr_checker import eval_comptime_expr
 
-        v = eval_comptime_expr(comptime_expr, Context(globals, Locals({}), {}))
+        v = eval_comptime_expr(comptime_expr, Context(ctx.globals, Locals({}), {}))
         if isinstance(v, int):
             nat_ty = NumericType(NumericType.Kind.Nat)
             return ConstArg(ConstValue(nat_ty, v))
@@ -128,7 +136,7 @@ def arg_from_ast(
     # Finally, we also support delayed annotations in strings
     if isinstance(node, ast.Constant) and isinstance(node.value, str):
         node = _parse_delayed_annotation(node.value, node)
-        return arg_from_ast(node, globals, param_var_mapping, allow_free_vars)
+        return arg_from_ast(node, ctx)
 
     raise GuppyError(InvalidTypeArgError(node))
 
@@ -165,28 +173,19 @@ def _try_parse_defn(node: AstNode, globals: Globals) -> Definition | None:
 
 
 def _arg_from_instantiated_defn(
-    defn: Definition,
-    arg_nodes: list[ast.expr],
-    globals: Globals,
-    node: AstNode,
-    param_var_mapping: dict[str, Parameter],
-    allow_free_vars: bool = False,
+    defn: Definition, arg_nodes: list[ast.expr], node: AstNode, ctx: TypeParsingCtx
 ) -> Argument:
     """Parses a globals definition with type args into an argument."""
     match defn:
         # Special case for the `Callable` type
         case CallableTypeDef():
-            return TypeArg(
-                _parse_callable_type(
-                    arg_nodes, node, globals, param_var_mapping, allow_free_vars
-                )
-            )
+            return TypeArg(_parse_callable_type(arg_nodes, node, ctx))
+            # Special case for the `Callable` type
+        case SelfTypeDef():
+            return TypeArg(_parse_self_type(arg_nodes, node, ctx))
         # Either a defined type (e.g. `int`, `bool`, ...)
         case TypeDef() as defn:
-            args = [
-                arg_from_ast(arg_node, globals, param_var_mapping, allow_free_vars)
-                for arg_node in arg_nodes
-            ]
+            args = [arg_from_ast(arg_node, ctx) for arg_node in arg_nodes]
             ty = defn.check_instantiate(args, node)
             return TypeArg(ty)
         # Or a parameter (e.g. `T`, `n`, ...)
@@ -194,12 +193,14 @@ def _arg_from_instantiated_defn(
             # We don't allow parametrised variables like `T[int]`
             if arg_nodes:
                 raise GuppyError(HigherKindedTypeVarError(node, defn))
-            if defn.name not in param_var_mapping:
-                if allow_free_vars:
-                    param_var_mapping[defn.name] = defn.to_param(len(param_var_mapping))
+            if defn.name not in ctx.param_var_mapping:
+                if ctx.allow_free_vars:
+                    ctx.param_var_mapping[defn.name] = defn.to_param(
+                        len(ctx.param_var_mapping)
+                    )
                 else:
                     raise GuppyError(FreeTypeVarError(node, defn))
-            return param_var_mapping[defn.name].to_bound()
+            return ctx.param_var_mapping[defn.name].to_bound()
         case defn:
             err = ExpectedError(node, "a type", got=f"{defn.description} `{defn.name}`")
             raise GuppyError(err)
@@ -224,11 +225,7 @@ def _parse_delayed_annotation(ast_str: str, node: ast.Constant) -> ast.expr:
 
 
 def _parse_callable_type(
-    args: list[ast.expr],
-    loc: AstNode,
-    globals: Globals,
-    param_var_mapping: dict[str, Parameter],
-    allow_free_vars: bool = False,
+    args: list[ast.expr], loc: AstNode, ctx: TypeParsingCtx
 ) -> FunctionType:
     """Helper function to parse a `Callable[[<arguments>], <return type>]` type."""
     err = InvalidCallableTypeError(loc)
@@ -237,59 +234,63 @@ def _parse_callable_type(
     [inputs, output] = args
     if not isinstance(inputs, ast.List):
         raise GuppyError(err)
-    inouts, output = parse_function_io_types(
-        inputs.elts, output, None, loc, globals, param_var_mapping, allow_free_vars
-    )
-    return FunctionType(inouts, output)
-
-
-def parse_function_io_types(
-    input_nodes: list[ast.expr],
-    output_node: ast.expr,
-    input_names: list[str] | None,
-    loc: AstNode,
-    globals: Globals,
-    param_var_mapping: dict[str, Parameter],
-    allow_free_vars: bool = False,
-) -> tuple[list[FuncInput], Type]:
-    """Parses the inputs and output types of a function type.
-
-    This function takes care of parsing annotations and any related checks.
-
-    Returns the parsed input and output types.
+    inputs = [parse_function_arg_annotation(inp, None, ctx) for inp in inputs.elts]
+    output = type_from_ast(output, ctx)
+    return FunctionType(inputs, output)
+
+
+def _parse_self_type(args: list[ast.expr], loc: AstNode, ctx: TypeParsingCtx) -> Type:
+    """Helper function to parse a `Self` type.
+
+    Returns the actual type `Self` refers to or emits a user error if we're not inside
+    a method.
     """
-    inputs = []
-    for i, inp in enumerate(input_nodes):
-        ty, flags = type_with_flags_from_ast(
-            inp, globals, param_var_mapping, allow_free_vars
+    if ctx.self_ty is None:
+        raise GuppyError(SelfTyNotInMethodError(loc))
+
+    # We don't allow specifying generic arguments of `Self`. This matches the behaviour
+    # of Python.
+    if args:
+        raise GuppyError(WrongNumberOfTypeArgsError(loc, 0, len(args), "Self"))
+    return ctx.self_ty
+
+
+def parse_function_arg_annotation(
+    annotation: ast.expr, name: str | None, ctx: TypeParsingCtx
+) -> FuncInput:
+    """Parses an annotation in the input of a function type."""
+    ty, flags = type_with_flags_from_ast(annotation, ctx)
+    return check_function_arg(ty, flags, annotation, name, ctx)
+
+
+def check_function_arg(
+    ty: Type, flags: InputFlags, loc: AstNode, name: str | None, ctx: TypeParsingCtx
+) -> FuncInput:
+    """Given a function input type and its user-provided flags, checks if the flags
+    are valid and inserts implicit flags."""
+    if InputFlags.Owned in flags and ty.copyable:
+        raise GuppyError(NonLinearOwnedError(loc, ty))
+    if not ty.copyable and InputFlags.Owned not in flags:
+        flags |= InputFlags.Inout
+    if InputFlags.Comptime in flags:
+        if name is None:
+            raise GuppyError(CallableComptimeError(loc))
+
+        # Make sure we're not shadowing a type variable with the same name that was
+        # already used on the left. E.g
+        #
+        #    n = guppy.type_var("n")
+        #    def foo(xs: array[int, n], n: nat @comptime)
+        #
+        # TODO: In principle we could lift this restriction by tracking multiple
+        #  params referring to the same name in `param_var_mapping`, but not sure if
+        #  this would be worth it...
+        if name in ctx.param_var_mapping:
+            raise GuppyError(ComptimeArgShadowError(loc, name))
+        ctx.param_var_mapping[name] = ConstParam(
+            len(ctx.param_var_mapping), name, ty, from_comptime_arg=True
         )
-        if InputFlags.Owned in flags and ty.copyable:
-            raise GuppyError(NonLinearOwnedError(loc, ty))
-        if not ty.copyable and InputFlags.Owned not in flags:
-            flags |= InputFlags.Inout
-        if InputFlags.Comptime in flags:
-            if input_names is None:
-                raise GuppyError(CallableComptimeError(inp))
-            name = input_names[i]
-
-            # Make sure we're not shadowing a type variable with the same name that was
-            # already used on the left. E.g
-            #
-            #    n = guppy.type_var("n")
-            #    def foo(xs: array[int, n], n: nat @comptime)
-            #
-            # TODO: In principle we could lift this restriction by tracking multiple
-            #  params referring to the same name in `param_var_mapping`, but not sure if
-            #  this would be worth it...
-            if name in param_var_mapping:
-                raise GuppyError(ComptimeArgShadowError(inp, name))
-            param_var_mapping[name] = ConstParam(
-                len(param_var_mapping), name, ty, from_comptime_arg=True
-            )
-
-        inputs.append(FuncInput(ty, flags))
-    output = type_from_ast(output_node, globals, param_var_mapping, allow_free_vars)
-    return inputs, output
+    return FuncInput(ty, flags)
 
 
 if sys.version_info >= (3, 12):
@@ -330,7 +331,8 @@ 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
-                ty = type_from_ast(bound, globals, {}, allow_free_vars=False)
+                ctx = TypeParsingCtx(globals, param_var_mapping={})
+                ty = type_from_ast(bound, ctx)
                 if not ty.copyable or not ty.droppable:
                     raise GuppyError(LinearConstParamError(bound, ty))
 
@@ -348,15 +350,10 @@ _type_param = TypeParam(0, "T", False, False)
 
 
 def type_with_flags_from_ast(
-    node: AstNode,
-    globals: Globals,
-    param_var_mapping: dict[str, Parameter],
-    allow_free_vars: bool = False,
+    node: AstNode, ctx: TypeParsingCtx
 ) -> tuple[Type, InputFlags]:
     if isinstance(node, ast.BinOp) and isinstance(node.op, ast.MatMult):
-        ty, flags = type_with_flags_from_ast(
-            node.left, globals, param_var_mapping, allow_free_vars
-        )
+        ty, flags = type_with_flags_from_ast(node.left, ctx)
         match node.right:
             case ast.Name(id="owned"):
                 if ty.copyable:
@@ -382,35 +379,24 @@ def type_with_flags_from_ast(
     # We also need to handle the case that this could be a delayed string annotation
     elif isinstance(node, ast.Constant) and isinstance(node.value, str):
         node = _parse_delayed_annotation(node.value, node)
-        return type_with_flags_from_ast(
-            node, globals, param_var_mapping, allow_free_vars
-        )
+        return type_with_flags_from_ast(node, ctx)
     else:
         # Parse an argument and check that it's valid for a `TypeParam`
-        arg = arg_from_ast(node, globals, param_var_mapping, allow_free_vars)
+        arg = arg_from_ast(node, ctx)
         tyarg = _type_param.check_arg(arg, node)
         return tyarg.ty, InputFlags.NoFlags
 
 
-def type_from_ast(
-    node: AstNode,
-    globals: Globals,
-    param_var_mapping: dict[str, Parameter],
-    allow_free_vars: bool = False,
-) -> Type:
+def type_from_ast(node: AstNode, ctx: TypeParsingCtx) -> Type:
     """Turns an AST expression into a Guppy type."""
-    ty, flags = type_with_flags_from_ast(
-        node, globals, param_var_mapping, allow_free_vars
-    )
+    ty, flags = type_with_flags_from_ast(node, ctx)
     if flags != InputFlags.NoFlags:
         assert InputFlags.Inout not in flags  # Users shouldn't be able to set this
         raise GuppyError(FlagNotAllowedError(node))
     return ty
 
 
-def type_row_from_ast(
-    node: ast.expr, globals: "Globals", allow_free_vars: bool = False
-) -> Sequence[Type]:
+def type_row_from_ast(node: ast.expr, ctx: TypeParsingCtx) -> Sequence[Type]:
     """Turns an AST expression into a Guppy type row.
 
     This is needed to interpret the return type annotation of functions.
@@ -418,7 +404,7 @@ def type_row_from_ast(
     # The return type `-> None` is represented in the ast as `ast.Constant(value=None)`
     if isinstance(node, ast.Constant) and node.value is None:
         return []
-    ty = type_from_ast(node, globals, {}, allow_free_vars)
+    ty = type_from_ast(node, ctx)
     if isinstance(ty, TupleType):
         return ty.element_types
     else:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guppylang-internals
-Version: 0.23.0
+Version: 0.24.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>
@@ -220,7 +220,7 @@ 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.10.0
+Requires-Dist: tket-exts~=0.11.0
 Requires-Dist: typing-extensions<5,>=4.9.0
 Provides-Extra: pytket
 Requires-Dist: pytket>=1.34; extra == 'pytket'
@@ -228,7 +228,7 @@ Description-Content-Type: text/markdown
 
 # guppylang-internals
 
-This packages contains the internals of the Guppy compiler. 
+This packages contains the internals of the Guppy compiler.
 
 See `guppylang` for the package providing the user-facing language frontend.
 

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

@@ -1,13 +1,13 @@
-guppylang_internals/__init__.py,sha256=lZyhpAJ-bru-ZxPcVJYGsj9BfAP5TrumwEBb5RV9Czk,130
+guppylang_internals/__init__.py,sha256=DGSTdGFDWX6LAry7XIDSqKcMw7qI9NIEAI_aS2gLKcc,130
 guppylang_internals/ast_util.py,sha256=Y_7MoilGpahv7tJ1xN5nVGIELZlhk-5h_9AbI3qixZg,11839
-guppylang_internals/decorator.py,sha256=-A3Xml0uvS4DJGd138ZjdP9aiK_orHCaJpF8IR0JSu8,8742
+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=KM3iY2gz5RrtEB44AWuz8P16Gk-ItDuUpsG9cDMtFyg,10251
+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/ipython_inspect.py,sha256=rY2DpSpSBrRk0IZmuoz7jh35kGZHQnHLAQQFdb_-WnI,931
-guppylang_internals/nodes.py,sha256=y9nlIiZIj1pfOEbBBveMkwuqmCfnfoqEBpGsGeMwQPc,10100
+guppylang_internals/nodes.py,sha256=Wvf12iU6rhx7RgqbbtcGPkiJwtQjgt6NMkYzmzZPAHc,9580
 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
@@ -17,11 +17,11 @@ guppylang_internals/cfg/builder.py,sha256=9WExlNvZkO0NcTgr4zATxk7Oys8Uas2me1leeD
 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=5c2X8AHwSBGQdk2eMiplhQ5lnl78bxQA2mJm3MFUty0,17675
-guppylang_internals/checker/expr_checker.py,sha256=4XVeJFcoorNDkbGXG3JAk8Rtq9-AP4f_BkqlgBVTun4,58698
-guppylang_internals/checker/func_checker.py,sha256=zpYJ4vj6Xe0cmhF43ISV7rnRqGqel6jZQQfY8oFv9yU,10090
+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=l-SNeep5pHvIr4ji4WwZBMwu56t_q2qA3SNbUAU4WoM,18848
+guppylang_internals/checker/stmt_checker.py,sha256=J1LT6rae8a_p2pbdHKJQTZdeDkZak017icotWWyBQHA,18827
 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
@@ -38,19 +38,19 @@ guppylang_internals/compiler/qtm_platform_extension.py,sha256=47DEQpj8HBSa-_TImW
 guppylang_internals/compiler/stmt_compiler.py,sha256=Td1-xgrYtQMstpy_qh90baCvwYXRk95M7SOJ7qyXO2s,9201
 guppylang_internals/definition/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/definition/common.py,sha256=Me7gpCTzOqDv7eRv6Wo5ynsMYy6MEDpeX9uY2acYRDI,6927
-guppylang_internals/definition/const.py,sha256=DF7B_o3JyQwetVlXpxNDyTgEb7UWH1JlEbIeA-oUy-U,2255
-guppylang_internals/definition/custom.py,sha256=4qpaSFXwG1BkV-3LnOso8Z_nGGlNVC_jJYh6H6ma_Pg,17920
-guppylang_internals/definition/declaration.py,sha256=kObHupYRMAnJv69rJApwnsYUPzOtbw9KIzug0ilMNiw,5885
-guppylang_internals/definition/extern.py,sha256=0nk3a8oIqdh0-1n6_5aw7pNfExZwih3EY80h1oO7vz8,2850
-guppylang_internals/definition/function.py,sha256=hOH-AD-jURjqIRjbYcKRAeFpxVvlPTI6N5pZT9khF2Y,10960
+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/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=a5lKQejBuVYBd5Y6wSZLTO6wALB7Nn4kMwqrsCvYMvA,2699
-guppylang_internals/definition/pytket_circuits.py,sha256=32oALaByJk0kpBLu3iJ1I1HpYxGgETf3IMqAyJb6qPo,18194
-guppylang_internals/definition/struct.py,sha256=zyprHpLTNqNAGfMvLQb-v7dTEtnrbcoRdzerB0akjzQ,15303
-guppylang_internals/definition/traced.py,sha256=_hK_x5vhNlctw_fBxcwbsSh0H-Od1fqkLqFPIKDugxM,5583
-guppylang_internals/definition/ty.py,sha256=WIqkwW04Jqpizn1pEVrLSL5TA-1SgYOlsnIV2TN8x10,1741
+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/traced.py,sha256=hMHnrLKdbMvmmzmcJRvOCR-WiPHJ3x5ji0am436HNTQ,5592
+guppylang_internals/definition/ty.py,sha256=Aw7kgDOGv3crRoESUlAeR_2ovX8kV0qhGhuHlGOLf1s,2081
 guppylang_internals/definition/value.py,sha256=tgkp-brIAauGXMqe68Fnwvz_bfdThdwJ_rzsGMbw95w,3452
-guppylang_internals/definition/wasm.py,sha256=RnaqySNRLsk-q3f8-NKIythnlLHF9TeZ2ivIHXq_JKo,1987
+guppylang_internals/definition/wasm.py,sha256=Op8IpiKRZkNX-90UBp7uu3nCxx2VkbKKxHz-DZQuWs0,1987
 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
@@ -70,29 +70,29 @@ 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=Q6RhXQU8Vm9HelpYyswdgYJUIr8scDuLlHFTZ9dkVhI,1468
-guppylang_internals/std/_internal/compiler/wasm.py,sha256=c5WUTLS3NVswuzYzROoUsOOeh_dkW_RnUuOeMI5kxLU,5220
+guppylang_internals/std/_internal/compiler/tket_exts.py,sha256=NteaIlCn4K0LoXwUCCLh39w7hoPdmpmdQ39_7P4ezKU,1381
+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=sH7BHQrx0Hdq_4aYWwxXwN3ANfnTvhT-7re7mirelOQ,7233
+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=JODTlg2LQ60UsRC37GNquzKvoFjR59P67FNSyMmIQcc,8770
+guppylang_internals/tracing/unpacking.py,sha256=i3qFl__DIdm8uuRfHNdisSLLxZ6hSe_8SFUTs8Bhv5Q,9075
 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=9WvxN3cBLKpfusU6d339gEtsTH8lXTW-4eCghWvG86k,11892
+guppylang_internals/tys/builtin.py,sha256=iLhqxXM4v66erI22-k__Xc_86ANw9_d7acUyrLq-yMM,12763
 guppylang_internals/tys/common.py,sha256=kCJDzSquUdztV5zEINE0Lxigawux9te0lmzd0Oa70J0,3575
 guppylang_internals/tys/const.py,sha256=MiD46lybIqkiXEh_7ekipYanIe7MahDwY8c-PWY0s3c,3718
-guppylang_internals/tys/errors.py,sha256=B42S1j9exGtx_zmNVr5bgEA6ZJ1pW7mIsKvb-KGX7oU,5323
+guppylang_internals/tys/errors.py,sha256=Llc1CXDqkXW6Hi-cpMJaTLKweSN2a2E4sHpXapC0VRA,5514
 guppylang_internals/tys/param.py,sha256=9GsfJ4Hjt4FkjgC4lFirUjE7oVkqTD-ACV0LJWstswI,9340
-guppylang_internals/tys/parsing.py,sha256=n1baSNb9SCZStuyTsSVuiOvkCoPPj__oH-MVqHY9AnI,16797
+guppylang_internals/tys/parsing.py,sha256=A7zwXvXLFze8wtxI0Am1VqG98ddgGw7vqevo_29qCoQ,16863
 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/var.py,sha256=zACXv2IvGrqjDryC6lMyZpNnDb3SBRM2SlTOyq6WJdo,1173
-guppylang_internals-0.23.0.dist-info/METADATA,sha256=NiaZE5IBZRTN_YMXkTwevI9wz-Jnaw1FiCc9Xv2Jsx0,14809
-guppylang_internals-0.23.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-guppylang_internals-0.23.0.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-guppylang_internals-0.23.0.dist-info/RECORD,,
+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,,