guppylang-internals 0.23.0__py3-none-any.whl → 0.25.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,9 +35,10 @@ 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
 from guppylang_internals.tys.ty import (
     FuncInput,
     FunctionType,
@@ -48,46 +50,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 +125,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 +135,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 +172,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 +192,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 +224,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,64 +233,74 @@ 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):
 
-    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"))
@@ -330,17 +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
-                ty = type_from_ast(bound, globals, {}, allow_free_vars=False)
+                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)
 
 
@@ -348,15 +347,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:
@@ -366,51 +360,30 @@ 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
     # 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 +391,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/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.23.0.dist-info → guppylang_internals-0.25.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guppylang-internals
-Version: 0.23.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.10.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'
@@ -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.