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

guppylang_internals/tracing/function.py

@@ -176,10 +176,21 @@ def trace_call(func: CallableDef, *args: Any) -> Any:
     if len(func.ty.inputs) != 0:
         for inp, arg, var in zip(func.ty.inputs, args, arg_vars, strict=True):
             if InputFlags.Inout in inp.flags:
+                # Note that `inp.ty` could refer to bound variables in the function
+                # signature. Instead, make sure to use `var.ty` which will always be a
+                # concrete type and type checking has ensured that they unify.
+                ty = var.ty
                 inout_wire = state.dfg[var]
-                update_packed_value(
-                    arg, GuppyObject(inp.ty, inout_wire), state.dfg.builder
+                success = update_packed_value(
+                    arg, GuppyObject(ty, inout_wire), state.dfg.builder
                 )
+                if not success:
+                    # This means the user has passed an object that we cannot update,
+                    # e.g. calling `mem_swap(x, y)` where the inputs are plain Python
+                    # objects
+                    raise GuppyComptimeError(
+                        f"Cannot borrow Python object of type `{ty}` at comptime"
+                    )
 
     ret_obj = GuppyObject(ret_ty, ret_wire)
     return unpack_guppy_object(ret_obj, state.dfg.builder)

guppylang_internals/tracing/unpacking.py

@@ -150,13 +150,15 @@ def guppy_object_from_py(
             return GuppyObject(ty, builder.load(hugr_val))
 
 
-def update_packed_value(v: Any, obj: "GuppyObject", builder: DfBase[P]) -> None:
+def update_packed_value(v: Any, obj: "GuppyObject", builder: DfBase[P]) -> bool:
     """Given a Python value `v` and a `GuppyObject` `obj` that was constructed from `v`
-    using `guppy_object_from_py`, updates the wires of any `GuppyObjects` contained in
-    `v` to the new wires specified by `obj`.
+    using `guppy_object_from_py`, tries to update the wires of any `GuppyObjects`
+    contained in `v` to the new wires specified by `obj`.
 
     Also resets the used flag on any of those updated wires. This corresponds to making
     the object available again since it now corresponds to a fresh wire.
+
+    Returns `True` if all wires could be updated, otherwise `False`.
     """
     match v:
         case GuppyObject() as v_obj:
@@ -172,23 +174,27 @@ def update_packed_value(v: Any, obj: "GuppyObject", builder: DfBase[P]) -> None:
             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):
-                update_packed_value(v, GuppyObject(ty, wire), builder)
+                success = update_packed_value(v, GuppyObject(ty, 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):
+            for field, wire in zip(ty.fields, wires, strict=True):
                 v = values[field.name]
-                update_packed_value(v, GuppyObject(field.ty, wire), builder)
+                success = update_packed_value(v, GuppyObject(field.ty, 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 v, opt_wire in zip(vs, opt_wires, strict=True):
+            for i, (v, opt_wire) in enumerate(zip(vs, opt_wires, strict=True)):
                 (wire,) = build_unwrap(builder, opt_wire, err).outputs()
-                update_packed_value(v, GuppyObject(elem_ty, wire), builder)
+                success = update_packed_value(v, GuppyObject(elem_ty, wire), builder)
+                if not success:
+                    vs[i] = obj
         case _:
-            pass
+            return False
+    return True

guppylang_internals/tys/builtin.py

@@ -46,6 +46,27 @@ class CallableTypeDef(TypeDef, CompiledDef):
         raise InternalGuppyError("Tried to `Callable` type via `check_instantiate`")
 
 
+@dataclass(frozen=True)
+class SelfTypeDef(TypeDef, CompiledDef):
+    """Type definition associated with the `Self` type on methods.
+
+    During type parsing, we make sure that this type is replaced with the concrete type
+    the method is attached to. Thus, we should never have instances of this type around.
+
+    In other words, this definition is only a marker so that type parsing doesn't have
+    to rely on matching against the string "Self". By making `Self` a definition, we can
+    use the existing identifier tracking system and also handle users shadowing the
+    `Self` binder or assigning `Self` to some other name.
+    """
+
+    name: Literal["Self"] = field(default="Self", init=False)
+
+    def check_instantiate(
+        self, args: Sequence[Argument], loc: AstNode | None = None
+    ) -> FunctionType:
+        raise InternalGuppyError("Tried to instantiate abstract `Self` type`")
+
+
 @dataclass(frozen=True)
 class _TupleTypeDef(TypeDef, CompiledDef):
     """Type definition associated with the builtin `tuple` type.
@@ -106,7 +127,6 @@ class _NumericTypeDef(TypeDef, CompiledDef):
 
 class WasmModuleTypeDef(OpaqueTypeDef):
     wasm_file: str
-    wasm_hash: int
 
     def __init__(
         self,
@@ -114,11 +134,9 @@ class WasmModuleTypeDef(OpaqueTypeDef):
         name: str,
         defined_at: ast.AST | None,
         wasm_file: str,
-        wasm_hash: int,
     ) -> None:
         super().__init__(id, name, defined_at, [], True, True, self.to_hugr)
         self.wasm_file = wasm_file
-        self.wasm_hash = wasm_hash
 
     def to_hugr(
         self, args: Sequence[TypeArg | ConstArg], ctx: ToHugrContext
@@ -189,9 +207,10 @@ def _option_to_hugr(args: Sequence[Argument], ctx: ToHugrContext) -> ht.Type:
     return ht.Option(arg.ty.to_hugr(ctx))
 
 
-callable_type_def = CallableTypeDef(DefId.fresh(), None)
-tuple_type_def = _TupleTypeDef(DefId.fresh(), None)
-none_type_def = _NoneTypeDef(DefId.fresh(), None)
+callable_type_def = CallableTypeDef(DefId.fresh(), None, None)
+self_type_def = SelfTypeDef(DefId.fresh(), None, [])
+tuple_type_def = _TupleTypeDef(DefId.fresh(), None, None)
+none_type_def = _NoneTypeDef(DefId.fresh(), None, [])
 bool_type_def = OpaqueTypeDef(
     id=DefId.fresh(),
     name="bool",
@@ -202,13 +221,13 @@ bool_type_def = OpaqueTypeDef(
     to_hugr=lambda args, ctx: OpaqueBool,
 )
 nat_type_def = _NumericTypeDef(
-    DefId.fresh(), "nat", None, NumericType(NumericType.Kind.Nat)
+    DefId.fresh(), "nat", None, [], NumericType(NumericType.Kind.Nat)
 )
 int_type_def = _NumericTypeDef(
-    DefId.fresh(), "int", None, NumericType(NumericType.Kind.Int)
+    DefId.fresh(), "int", None, [], NumericType(NumericType.Kind.Int)
 )
 float_type_def = _NumericTypeDef(
-    DefId.fresh(), "float", None, NumericType(NumericType.Kind.Float)
+    DefId.fresh(), "float", None, [], NumericType(NumericType.Kind.Float)
 )
 string_type_def = OpaqueTypeDef(
     id=DefId.fresh(),
@@ -345,9 +364,9 @@ def is_sized_iter_type(ty: Type) -> TypeGuard[OpaqueType]:
     return isinstance(ty, OpaqueType) and ty.defn == sized_iter_type_def
 
 
-def wasm_module_info(ty: Type) -> tuple[str, int] | None:
+def wasm_module_name(ty: Type) -> str | None:
     if isinstance(ty, OpaqueType) and isinstance(ty.defn, WasmModuleTypeDef):
-        return ty.defn.wasm_file, ty.defn.wasm_hash
+        return ty.defn.wasm_file
     return None
 
 

guppylang_internals/tys/errors.py

@@ -116,6 +116,12 @@ class InvalidCallableTypeError(Error):
         self.add_sub_diagnostic(InvalidCallableTypeError.Explain(None))
 
 
+@dataclass(frozen=True)
+class SelfTyNotInMethodError(Error):
+    title: ClassVar[str] = "Invalid type"
+    span_label: ClassVar[str] = "`Self` type annotations are only allowed in methods"
+
+
 @dataclass(frozen=True)
 class NonLinearOwnedError(Error):
     title: ClassVar[str] = "Invalid annotation"

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.22.0.dist-info → guppylang_internals-0.24.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guppylang-internals
-Version: 0.22.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>
@@ -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.14,>=0.13.0rc1
-Requires-Dist: tket-exts~=0.10.0
+Requires-Dist: hugr~=0.13.1
+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.
 
@@ -250,4 +250,4 @@ See [DEVELOPMENT.md] information on how to develop and contribute to this packag
 
 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/CQCL/guppylang/blob/main/LICENCE