guppylang-internals 0.21.0__py3-none-any.whl → 0.21.2__py3-none-any.whl

guppylang_internals/__init__.py

@@ -1,3 +1,3 @@
 # This is updated by our release-please workflow, triggered by this
 # annotation: x-release-please-version
-__version__ = "0.21.0"
+__version__ = "0.21.2"

guppylang_internals/checker/expr_checker.py

@@ -1365,6 +1365,8 @@ def python_value_to_guppy_type(
             return TupleType(cast(list[Type], tys))
         case list():
             return _python_list_to_guppy_type(v, node, globals, type_hint)
+        case None:
+            return NoneType()
         case _:
             return None
 

guppylang_internals/checker/stmt_checker.py

@@ -54,6 +54,7 @@ from guppylang_internals.checker.expr_checker import (
 from guppylang_internals.error import GuppyError, GuppyTypeError, InternalGuppyError
 from guppylang_internals.nodes import (
     AnyUnpack,
+    ArrayUnpack,
     DesugaredArrayComp,
     IterableUnpack,
     MakeIter,
@@ -65,6 +66,7 @@ from guppylang_internals.nodes import (
 from guppylang_internals.span import Span, to_span
 from guppylang_internals.tys.builtin import (
     array_type,
+    get_array_length,
     get_element_type,
     get_iter_size,
     is_array_type,
@@ -260,8 +262,10 @@ class StmtChecker(AstVisitor[BBStatement]):
             assert all_equal(starred_tys)
             if starred_tys:
                 starred_ty, *_ = starred_tys
-            # Starred part could be empty. If it's an iterable unpack, we're still fine
-            # since we know the yielded type
+            # Starred part could be empty. If it's an array or iterable unpack, we're
+            # still fine since we know the yielded type
+            elif isinstance(unpack, ArrayUnpack):
+                starred_ty = unpack.elt_type
             elif isinstance(unpack, IterableUnpack):
                 starred_ty = unpack.compr.elt_ty
             # For tuple unpacks, there is no way to infer a type for the empty starred
@@ -304,6 +308,19 @@ class StmtChecker(AstVisitor[BBStatement]):
             elts = expr.elts if isinstance(expr, ast.Tuple) else [expr] * len(tys)
             return TupleUnpack(pattern), elts, tys
 
+        elif is_array_type(ty):
+            match get_array_length(ty):
+                case ConstValue(value=int(size)):
+                    elt_ty = get_element_type(ty)
+                    unpack = ArrayUnpack(pattern, size, elt_ty)
+                    return unpack, size * [expr], size * [elt_ty]
+                case generic_size:
+                    err = UnpackableError(expr, get_type(expr))
+                    err.add_sub_diagnostic(
+                        UnpackableError.GenericSize(None, generic_size)
+                    )
+                    raise GuppyError(err)
+
         elif self.ctx.globals.get_instance_func(ty, "__iter__"):
             size = check_iter_unpack_has_static_size(expr, self.ctx)
             # Create a dummy variable and assign the expression to it. This helps us to

guppylang_internals/compiler/core.py

@@ -8,12 +8,14 @@ from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 import tket_exts
 from hugr import Hugr, Node, Wire, ops
+from hugr import ext as he
 from hugr import tys as ht
 from hugr.build import function as hf
 from hugr.build.dfg import DP, DefinitionBuilder, DfBase
 from hugr.hugr.base import OpVarCov
 from hugr.hugr.node_port import ToNode
 from hugr.std import PRELUDE
+from hugr.std.collections.array import EXTENSION as ARRAY_EXTENSION
 from typing_extensions import assert_never
 
 from guppylang_internals.checker.core import (
@@ -36,6 +38,7 @@ from guppylang_internals.definition.value import CompiledCallableDef
 from guppylang_internals.diagnostic import Error
 from guppylang_internals.engine import ENGINE
 from guppylang_internals.error import GuppyError, InternalGuppyError
+from guppylang_internals.std._internal.compiler.tket_exts import GUPPY_EXTENSION
 from guppylang_internals.tys.arg import ConstArg, TypeArg
 from guppylang_internals.tys.builtin import nat_type
 from guppylang_internals.tys.common import ToHugrContext
@@ -114,7 +117,7 @@ class EntryMonomorphizeError(Error):
     title: ClassVar[str] = "Invalid entry point"
     span_label: ClassVar[str] = (
         "Function `{name}` is not a valid compilation entry point since the value of "
-        "generic paramater `{param}` is not known"
+        "generic parameter `{param}` is not known"
     )
     name: str
     param: Parameter
@@ -242,6 +245,11 @@ class CompilerContext(ToHugrContext):
             with track_hugr_side_effects(), self.set_monomorphized_args(mono_args):
                 next_def.compile_inner(self)
 
+        # Insert explicit drops for affine types
+        # TODO: This is a quick workaround until we can properly insert these drops
+        #   during linearity checking. See https://github.com/CQCL/guppylang/issues/1082
+        insert_drops(self.module.hugr)
+
         return entry_compiled
 
     def build_compiled_instance_func(
@@ -611,3 +619,78 @@ def track_hugr_side_effects() -> Iterator[None]:
         yield
     finally:
         Hugr.add_node = hugr_add_node  # type: ignore[method-assign]
+
+
+def qualified_name(type_def: he.TypeDef) -> str:
+    """Returns the qualified name of a Hugr extension type.
+    TODO: Remove once upstreamed, see https://github.com/CQCL/hugr/issues/2426
+    """
+    if type_def._extension is not None:
+        return f"{type_def._extension.name}.{type_def.name}"
+    return type_def.name
+
+
+#: List of linear extension types that correspond to affine Guppy types and thus require
+#: insertion of an explicit drop operation.
+AFFINE_EXTENSION_TYS: list[str] = [
+    qualified_name(ARRAY_EXTENSION.get_type("array")),
+]
+
+
+def requires_drop(ty: ht.Type) -> bool:
+    """Checks if a Hugr type requires an implicit drop op insertion.
+    This is the case for linear Hugr types that correspond to affine Guppy types, or
+    any other type containing one of those. See `AFFINE_EXTENSION_TYS`.
+    """
+    match ty:
+        case ht.ExtType(type_def=type_def, args=args):
+            return qualified_name(type_def) in AFFINE_EXTENSION_TYS or any(
+                requires_drop(arg.ty) for arg in args if isinstance(arg, ht.TypeTypeArg)
+            )
+        case ht.Opaque(id=name, extension=extension, args=args):
+            qualified = f"{extension}.{name}" if extension else name
+            return qualified in AFFINE_EXTENSION_TYS or any(
+                requires_drop(arg.ty) for arg in args if isinstance(arg, ht.TypeTypeArg)
+            )
+        case ht.Sum(variant_rows=rows):
+            return any(requires_drop(ty) for row in rows for ty in row)
+        case ht.Variable(bound=bound):
+            return bound == ht.TypeBound.Linear
+        case ht.FunctionType():
+            return False
+        case ht.Alias():
+            raise InternalGuppyError("Alias should not be emitted!")
+        case _:
+            return False
+
+
+def drop_op(ty: ht.Type) -> ops.ExtOp:
+    """Returns the operation to drop affine values."""
+    return GUPPY_EXTENSION.get_op("drop").instantiate(
+        [ht.TypeTypeArg(ty)], ht.FunctionType([ty], [])
+    )
+
+
+def insert_drops(hugr: Hugr[OpVarCov]) -> None:
+    """Inserts explicit drop ops for unconnected ports into the Hugr.
+    TODO: This is a quick workaround until we can properly insert these drops during
+      linearity checking. See https://github.com/CQCL/guppylang/issues/1082
+    """
+    for node in hugr:
+        data = hugr[node]
+        # Iterating over `node.outputs()` doesn't work reliably since it sometimes
+        # raises an `IncompleteOp` exception. Instead, we query the number of out ports
+        # and look them up by index. However, this method is *also* broken when
+        # isnpecting `FuncDefn` nodes due to https://github.com/CQCL/hugr/issues/2438.
+        if isinstance(data.op, ops.FuncDefn):
+            continue
+        for i in range(hugr.num_out_ports(node)):
+            port = node.out(i)
+            kind = hugr.port_kind(port)
+            if (
+                next(iter(hugr.linked_ports(port)), None) is None
+                and isinstance(kind, ht.ValueKind)
+                and requires_drop(kind.ty)
+            ):
+                drop = hugr.add_node(drop_op(kind.ty), parent=data.parent)
+                hugr.add_link(port, drop.inp(0))

guppylang_internals/compiler/expr_compiler.py

@@ -828,6 +828,8 @@ def python_value_to_hugr(v: Any, exp_ty: Type, ctx: CompilerContext) -> hv.Value
                 return hugr.std.collections.static_array.StaticArrayVal(
                     vs, elem_ty.to_hugr(ctx), name=f"static_pyarray.{next(tmp_vars)}"
                 )
+        case None:
+            return hugr.val.Unit
         case _:
             return None
     return None

guppylang_internals/compiler/stmt_compiler.py

@@ -17,6 +17,7 @@ from guppylang_internals.compiler.core import (
 from guppylang_internals.compiler.expr_compiler import ExprCompiler
 from guppylang_internals.error import InternalGuppyError
 from guppylang_internals.nodes import (
+    ArrayUnpack,
     CheckedNestedFunctionDef,
     IterableUnpack,
     PlaceNode,
@@ -124,15 +125,12 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
             self._assign(starred, array)
 
     @_assign.register
-    def _assign_iterable(self, lhs: IterableUnpack, port: Wire) -> None:
-        """Handles assignment where the RHS is an iterable that should be unpacked."""
-        # Given an assignment pattern `left, *starred, right`, collect the RHS into an
-        # array and pop from the left and right, leaving us with the starred array in
-        # the middle
-        assert isinstance(lhs.compr.length, ConstValue)
-        length = lhs.compr.length.value
-        assert isinstance(length, int)
-        opt_elt_ty = ht.Option(lhs.compr.elt_ty.to_hugr(self.ctx))
+    def _assign_array(self, lhs: ArrayUnpack, port: Wire) -> None:
+        """Handles assignment where the RHS is an array that should be unpacked."""
+        # Given an assignment pattern `left, *starred, right`, pop from the left and
+        # right, leaving us with the starred array in the middle
+        length = lhs.length
+        opt_elt_ty = ht.Option(lhs.elt_type.to_hugr(self.ctx))
 
         def pop(
             array: Wire, length: int, pats: list[ast.expr], from_left: bool
@@ -159,8 +157,7 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
                 self._assign(pat, elt)
             return array, length - num_pats
 
-        self.dfg[lhs.rhs_var.place] = port
-        array = self.expr_compiler.visit_DesugaredArrayComp(lhs.compr)
+        array = port
         array, length = pop(array, length, lhs.pattern.left, True)
         array, length = pop(array, length, lhs.pattern.right, False)
         if lhs.pattern.starred:
@@ -169,6 +166,20 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
             assert length == 0
             self.builder.add_op(array_discard_empty(opt_elt_ty), array)
 
+    @_assign.register
+    def _assign_iterable(self, lhs: IterableUnpack, port: Wire) -> None:
+        """Handles assignment where the RHS is an iterable that should be unpacked."""
+        # Collect the RHS into an array by building the comprehension and then fall back
+        # to the array case above
+        assert isinstance(lhs.compr.length, ConstValue)
+        length = lhs.compr.length.value
+        assert isinstance(length, int)
+
+        self.dfg[lhs.rhs_var.place] = port
+        array = self.expr_compiler.visit_DesugaredArrayComp(lhs.compr)
+        unpack = ArrayUnpack(lhs.pattern, length, lhs.compr.elt_ty)
+        self._assign_array(unpack, array)
+
     def visit_Assign(self, node: ast.Assign) -> None:
         [target] = node.targets
         port = self.expr_compiler.compile(node.value, self.dfg)

guppylang_internals/decorator.py

@@ -1,16 +1,11 @@
-import builtins
+from __future__ import annotations
+
 import inspect
-from collections.abc import Callable, Sequence
-from types import FrameType
-from typing import ParamSpec, TypeVar
+from typing import TYPE_CHECKING, ParamSpec, TypeVar
 
 from hugr import ops
 from hugr import tys as ht
 
-from guppylang.defs import (
-    GuppyDefinition,
-    GuppyFunctionDefinition,
-)
 from guppylang_internals.compiler.core import (
     CompilerContext,
     GlobalConstId,
@@ -27,6 +22,7 @@ from guppylang_internals.definition.custom import (
 )
 from guppylang_internals.definition.ty import OpaqueTypeDef, TypeDef
 from guppylang_internals.definition.wasm import RawWasmFunctionDef
+from guppylang_internals.dummy_decorator import _dummy_custom_decorator, sphinx_running
 from guppylang_internals.engine import DEF_STORE
 from guppylang_internals.std._internal.checker import WasmCallChecker
 from guppylang_internals.std._internal.compiler.wasm import (
@@ -34,12 +30,9 @@ from guppylang_internals.std._internal.compiler.wasm import (
     WasmModuleDiscardCompiler,
     WasmModuleInitCompiler,
 )
-from guppylang_internals.tys.arg import Argument
 from guppylang_internals.tys.builtin import (
     WasmModuleTypeDef,
 )
-from guppylang_internals.tys.param import Parameter
-from guppylang_internals.tys.subst import Inst
 from guppylang_internals.tys.ty import (
     FuncInput,
     FunctionType,
@@ -48,6 +41,16 @@ from guppylang_internals.tys.ty import (
     NumericType,
 )
 
+if TYPE_CHECKING:
+    import builtins
+    from collections.abc import Callable, Sequence
+    from types import FrameType
+
+    from guppylang.defs import GuppyDefinition, GuppyFunctionDefinition
+    from guppylang_internals.tys.arg import Argument
+    from guppylang_internals.tys.param import Parameter
+    from guppylang_internals.tys.subst import Inst
+
 T = TypeVar("T")
 P = ParamSpec("P")
 
@@ -78,6 +81,7 @@ def custom_function(
     that case, the function signature can be omitted if a custom call compiler is
     provided.
     """
+    from guppylang.defs import GuppyFunctionDefinition
 
     def dec(f: Callable[P, T]) -> GuppyFunctionDefinition[P, T]:
         call_checker = checker or DefaultCallChecker()
@@ -119,6 +123,7 @@ def hugr_op(
 
 def extend_type(defn: TypeDef) -> Callable[[type], type]:
     """Decorator to add new instance functions to a type."""
+    from guppylang.defs import GuppyDefinition
 
     def dec(c: type) -> type:
         for val in c.__dict__.values():
@@ -147,6 +152,8 @@ def custom_type(
     For generic types, a callable may be passed that takes the type arguments of a
     concrete instantiation.
     """
+    from guppylang.defs import GuppyDefinition
+
     mk_hugr_ty = (
         (lambda args, ctx: hugr_ty) if isinstance(hugr_ty, ht.Type) else hugr_ty
     )
@@ -176,6 +183,8 @@ def custom_type(
 def wasm_module(
     filename: str, filehash: int
 ) -> Callable[[builtins.type[T]], GuppyDefinition]:
+    from guppylang.defs import GuppyDefinition
+
     def dec(cls: builtins.type[T]) -> GuppyDefinition:
         # N.B. Only one module per file and vice-versa
         wasm_module = WasmModuleTypeDef(
@@ -229,6 +238,8 @@ def wasm_module(
 
 
 def wasm(f: Callable[P, T]) -> GuppyFunctionDefinition[P, T]:
+    from guppylang.defs import GuppyFunctionDefinition
+
     func = RawWasmFunctionDef(
         DefId.fresh(),
         f.__name__,
@@ -243,4 +254,11 @@ def wasm(f: Callable[P, T]) -> GuppyFunctionDefinition[P, T]:
     return GuppyFunctionDefinition(func)
 
 
-# TODO sphinx hack for custom decorators
+# Override decorators with dummy versions if we're running a sphinx build
+if not TYPE_CHECKING and sphinx_running():
+    custom_function = _dummy_custom_decorator
+    hugr_op = _dummy_custom_decorator
+    extend_type = _dummy_custom_decorator
+    custom_type = _dummy_custom_decorator
+    wasm_module = _dummy_custom_decorator
+    wasm = _dummy_custom_decorator()

guppylang_internals/definition/pytket_circuits.py

@@ -7,6 +7,7 @@ from hugr import Node, Wire, envelope, ops, val
 from hugr import tys as ht
 from hugr.build.dfg import DefinitionBuilder, OpVar
 from hugr.envelope import EnvelopeConfig
+from hugr.std.float import FLOAT_T
 
 from guppylang_internals.ast_util import AstNode, has_empty_body, with_loc
 from guppylang_internals.checker.core import Context, Globals
@@ -37,17 +38,17 @@ from guppylang_internals.definition.value import (
     CompiledCallableDef,
     CompiledHugrNodeDef,
 )
+from guppylang_internals.engine import ENGINE
 from guppylang_internals.error import GuppyError, InternalGuppyError
 from guppylang_internals.nodes import GlobalCall
 from guppylang_internals.span import SourceMap, Span, ToSpan
 from guppylang_internals.std._internal.compiler.array import (
-    array_discard_empty,
     array_new,
-    array_pop,
+    array_unpack,
 )
 from guppylang_internals.std._internal.compiler.prelude import build_unwrap
 from guppylang_internals.std._internal.compiler.tket_bool import OpaqueBool, make_opaque
-from guppylang_internals.tys.builtin import array_type, bool_type
+from guppylang_internals.tys.builtin import array_type, bool_type, float_type
 from guppylang_internals.tys.subst import Inst, Subst
 from guppylang_internals.tys.ty import (
     FuncInput,
@@ -87,9 +88,7 @@ class RawPytketDef(ParsableDef):
         stub_signature = check_signature(func_ast, globals)
 
         # Compare signatures.
-        circuit_signature = _signature_from_circuit(
-            self.input_circuit, globals, self.defined_at
-        )
+        circuit_signature = _signature_from_circuit(self.input_circuit, self.defined_at)
         if not (
             circuit_signature.inputs == stub_signature.inputs
             and circuit_signature.output == stub_signature.output
@@ -126,7 +125,7 @@ class RawLoadPytketDef(ParsableDef):
     def parse(self, globals: Globals, sources: SourceMap) -> "ParsedPytketDef":
         """Creates a function signature based on the user-provided circuit."""
         circuit_signature = _signature_from_circuit(
-            self.input_circuit, globals, self.source_span, self.use_arrays
+            self.input_circuit, self.source_span, self.use_arrays
         )
 
         return ParsedPytketDef(
@@ -174,6 +173,7 @@ class ParsedPytketDef(CallableDef, CompilableDef):
                 circ = envelope.read_envelope(
                     Tk2Circuit(self.input_circuit).to_bytes(EnvelopeConfig.TEXT)
                 ).modules[0]
+
                 mapping = module.hugr.insert_hugr(circ)
                 hugr_func = mapping[circ.entrypoint]
 
@@ -182,47 +182,87 @@ class ParsedPytketDef(CallableDef, CompilableDef):
                     self.name, func_type.body.input, func_type.body.output
                 )
 
-                # Initialise every input bit in the circuit as false.
-                # TODO: Provide the option for the user to pass this input as well.
-                bool_wires = [
-                    outer_func.load(val.FALSE) for _ in range(self.input_circuit.n_bits)
-                ]
+                # Number of qubit inputs in the outer function.
+                offset = (
+                    len(self.input_circuit.q_registers)
+                    if self.use_arrays
+                    else self.input_circuit.n_qubits
+                )
 
-                input_list = []
+                input_list: list[Wire] = []
                 if self.use_arrays:
                     # If the input is given as arrays, we need to unpack each element in
                     # them into separate wires.
-                    # TODO: Replace with actual unpack HUGR op once
-                    # https://github.com/CQCL/hugr/issues/1947 is done.
-                    def unpack(
-                        array: Wire, elem_ty: ht.Type, length: int
-                    ) -> list[Wire]:
-                        err = "Internal error: unpacking of array failed"
-                        elts: list[Wire] = []
-                        for i in range(length):
-                            res = outer_func.add_op(
-                                array_pop(elem_ty, length - i, True), array
+                    for i, q_reg in enumerate(self.input_circuit.q_registers):
+                        reg_wire = outer_func.inputs()[i]
+                        opt_elem_wires = outer_func.add_op(
+                            array_unpack(ht.Option(ht.Qubit), q_reg.size), reg_wire
+                        )
+                        elem_wires = [
+                            build_unwrap(
+                                outer_func,
+                                opt_elem,
+                                "Internal error: unwrapping of array element failed",
                             )
-                            [elt_opt, array] = build_unwrap(outer_func, res, err)
-                            [elt] = build_unwrap(outer_func, elt_opt, err)
-                            elts.append(elt)
-                        outer_func.add_op(array_discard_empty(elem_ty), array)
-                        return elts
-
-                    # Must be same length due to earlier signature computation /
-                    # comparison.
-                    for q_reg, wire in zip(
-                        self.input_circuit.q_registers,
-                        list(outer_func.inputs()),
-                        strict=True,
-                    ):
-                        input_list.extend(unpack(wire, ht.Option(ht.Qubit), q_reg.size))
+                            for opt_elem in opt_elem_wires
+                        ]
+                        input_list.extend(elem_wires)
 
                 else:
                     # Otherwise pass inputs directly.
-                    input_list = list(outer_func.inputs())
+                    input_list = list(outer_func.inputs()[:offset])
 
-                call_node = outer_func.call(hugr_func, *(input_list + bool_wires))
+                # Initialise every input bit in the circuit as false.
+                # TODO: Provide the option for the user to pass this input as well.
+                bool_wires = [
+                    outer_func.load(val.FALSE) for _ in range(self.input_circuit.n_bits)
+                ]
+
+                # Symbolic parameters (if present) get passed after qubits and bools.
+                has_params = len(self.input_circuit.free_symbols()) != 0
+                if has_params and "TKET1.input_parameters" not in hugr_func.metadata:
+                    raise InternalGuppyError(
+                        "Parameter metadata is missing from pytket circuit HUGR"
+                    ) from None
+                param_wires: list[Wire] = []
+                # We assume they are given in lexicographic order by the user, then we
+                # wire them up according to the metadata order.
+                if has_params:
+                    lex_params: list[Wire] = list(outer_func.inputs()[offset:])
+                    if self.use_arrays:
+                        opt_param_wires = outer_func.add_op(
+                            array_unpack(
+                                ht.Option(ht.Tuple(float_type().to_hugr(ctx))),
+                                q_reg.size,
+                            ),
+                            lex_params[0],
+                        )
+                        lex_params = [
+                            build_unwrap(
+                                outer_func,
+                                opt_param,
+                                "Internal error: unwrapping of array element failed",
+                            )
+                            for opt_param in opt_param_wires
+                        ]
+                    param_order = cast(
+                        list[str], hugr_func.metadata["TKET1.input_parameters"]
+                    )
+                    lex_names = sorted(param_order)
+                    assert len(lex_names) == len(lex_params)
+                    name_to_param = dict(zip(lex_names, lex_params, strict=True))
+                    angle_wires = [name_to_param[name] for name in param_order]
+                    # Need to convert all angles to floats.
+                    for angle in angle_wires:
+                        [halfturns] = outer_func.add_op(
+                            ops.UnpackTuple([FLOAT_T]), angle
+                        )
+                        param_wires.append(halfturns)
+
+                # Pass all arguments to call node.
+                call_node = outer_func.call(
+                    hugr_func, *(input_list + bool_wires + param_wires)
+                )
 
                 # Pytket circuit hugr has qubit and bool wires in the opposite
                 # order to Guppy output wires.
@@ -354,7 +394,6 @@ class CompiledPytketDef(ParsedPytketDef, CompiledCallableDef, CompiledHugrNodeDe
 
 def _signature_from_circuit(
     input_circuit: Any,
-    globals: Globals,
     defined_at: ToSpan | None,
     use_arrays: bool = False,
 ) -> FunctionType:
@@ -367,16 +406,28 @@ def _signature_from_circuit(
                 import tket  # type: ignore[import-untyped, import-not-found, unused-ignore]  # noqa: F401
 
                 from guppylang.defs import GuppyDefinition
+                from guppylang.std.angles import angle
                 from guppylang.std.quantum import qubit
 
                 assert isinstance(qubit, GuppyDefinition)
                 qubit_ty = cast(TypeDef, qubit.wrapped).check_instantiate([])
 
+                angle_defn = ENGINE.get_checked(angle.id)  # type: ignore[attr-defined]
+                assert isinstance(angle_defn, TypeDef)
+                angle_ty = angle_defn.check_instantiate([])
+
                 if use_arrays:
                     inputs = [
                         FuncInput(array_type(qubit_ty, q_reg.size), InputFlags.Inout)
                         for q_reg in input_circuit.q_registers
                     ]
+                    if len(input_circuit.free_symbols()) != 0:
+                        inputs.append(
+                            FuncInput(
+                                array_type(angle_ty, len(input_circuit.free_symbols())),
+                                InputFlags.NoFlags,
+                            )
+                        )
                     outputs = [
                         array_type(bool_type(), c_reg.size)
                         for c_reg in input_circuit.c_registers
@@ -386,9 +437,13 @@ def _signature_from_circuit(
                         row_to_type(outputs),
                     )
                 else:
+                    param_inputs = [
+                        FuncInput(angle_ty, InputFlags.NoFlags)
+                        for _ in range(len(input_circuit.free_symbols()))
+                    ]
                     circuit_signature = FunctionType(
-                        [FuncInput(qubit_ty, InputFlags.Inout)]
-                        * input_circuit.n_qubits,
+                        [FuncInput(qubit_ty, InputFlags.Inout)] * input_circuit.n_qubits
+                        + param_inputs,
                         row_to_type([bool_type()] * input_circuit.n_bits),
                     )
             except ImportError:

guppylang_internals/dummy_decorator.py

@@ -64,6 +64,11 @@ class _DummyGuppy:
         return None
 
 
+def _dummy_custom_decorator(*args: Any, **kwargs: Any) -> Any:
+    """Dummy version of custom decorators that are used during Sphinx builds."""
+    return lambda f: f
+
+
 def sphinx_running() -> bool:
     """Checks if guppylang was imported during a sphinx build."""
     # This is the most general solution available at the moment.

guppylang_internals/nodes.py

@@ -363,6 +363,26 @@ class TupleUnpack(ast.expr):
     _fields = ("pattern",)
 
 
+class ArrayUnpack(ast.expr):
+    """The LHS of an unpacking assignment of an array."""
+
+    #: The (possibly starred) unpacking pattern
+    pattern: UnpackPattern
+
+    #: Length of the array
+    length: int
+
+    #: Element type of the array
+    elt_type: Type
+
+    _fields = ("pattern",)
+
+    def __init__(self, pattern: UnpackPattern, length: int, elt_type: Type) -> None:
+        super().__init__(pattern)
+        self.length = length
+        self.elt_type = elt_type
+
+
 class IterableUnpack(ast.expr):
     """The LHS of an unpacking assignment of an iterable type."""
 
@@ -388,7 +408,7 @@ class IterableUnpack(ast.expr):
 
 
 #: Any unpacking operation.
-AnyUnpack = TupleUnpack | IterableUnpack
+AnyUnpack = TupleUnpack | ArrayUnpack | IterableUnpack
 
 
 class NestedFunctionDef(ast.FunctionDef):

guppylang_internals/std/_internal/checker.py

@@ -1,10 +1,10 @@
 import ast
 from dataclasses import dataclass
-from typing import ClassVar, cast
+from typing import ClassVar
 
 from typing_extensions import assert_never
 
-from guppylang_internals.ast_util import get_type, with_loc, with_type
+from guppylang_internals.ast_util import get_type, with_loc
 from guppylang_internals.checker.core import ComptimeVariable, Context
 from guppylang_internals.checker.errors.generic import ExpectedError, UnsupportedError
 from guppylang_internals.checker.errors.type_errors import (
@@ -23,7 +23,6 @@ from guppylang_internals.checker.expr_checker import (
 from guppylang_internals.definition.custom import (
     CustomCallChecker,
 )
-from guppylang_internals.definition.struct import CheckedStructDef, RawStructDef
 from guppylang_internals.diagnostic import Error, Note
 from guppylang_internals.error import GuppyError, GuppyTypeError, InternalGuppyError
 from guppylang_internals.nodes import (
@@ -31,7 +30,6 @@ from guppylang_internals.nodes import (
     DesugaredArrayComp,
     DesugaredGeneratorExpr,
     ExitKind,
-    GenericParamValue,
     GlobalCall,
     MakeIter,
     PanicExpr,
@@ -61,7 +59,6 @@ from guppylang_internals.tys.ty import (
     InputFlags,
     NoneType,
     NumericType,
-    StructType,
     Type,
     unify,
 )
@@ -495,45 +492,6 @@ class ExitChecker(CustomCallChecker):
         return expr, {}
 
 
-class RangeChecker(CustomCallChecker):
-    """Call checker for the `range` function."""
-
-    def synthesize(self, args: list[ast.expr]) -> tuple[ast.expr, Type]:
-        check_num_args(1, len(args), self.node)
-        [stop] = args
-        stop_checked, _ = ExprChecker(self.ctx).check(stop, int_type(), "argument")
-        range_iter, range_ty = self.make_range(stop_checked)
-        # Check if `stop` is a statically known value. Note that we need to do this on
-        # the original `stop` instead of `stop_checked` to avoid any previously inserted
-        # `int` coercions.
-        if (static_stop := self.check_static(stop)) is not None:
-            return to_sized_iter(range_iter, range_ty, static_stop, self.ctx)
-        return range_iter, range_ty
-
-    def check_static(self, stop: ast.expr) -> "int | Const | None":
-        stop, _ = ExprSynthesizer(self.ctx).synthesize(stop, allow_free_vars=True)
-        if isinstance(stop, ast.Constant) and isinstance(stop.value, int):
-            return stop.value
-        if isinstance(stop, GenericParamValue) and stop.param.ty == nat_type():
-            return stop.param.to_bound().const
-        return None
-
-    def range_ty(self) -> StructType:
-        from guppylang.std.builtins import Range
-        from guppylang_internals.engine import ENGINE
-
-        def_id = cast(RawStructDef, Range).id
-        range_type_def = ENGINE.get_checked(def_id)
-        assert isinstance(range_type_def, CheckedStructDef)
-        return StructType([], range_type_def)
-
-    def make_range(self, stop: ast.expr) -> tuple[ast.expr, Type]:
-        make_range = self.ctx.globals.get_instance_func(self.range_ty(), "__new__")
-        assert make_range is not None
-        start = with_type(int_type(), with_loc(self.node, ast.Constant(value=0)))
-        return make_range.synthesize_call([start, stop], self.node, self.ctx)
-
-
 def to_sized_iter(
     iterator: ast.expr, range_ty: Type, size: "int | Const", ctx: Context
 ) -> tuple[ast.expr, Type]:

guppylang_internals/std/_internal/compiler/tket_exts.py

@@ -4,6 +4,7 @@ from hugr import val
 from tket_exts import (
     debug,
     futures,
+    guppy,
     opaque_bool,
     qsystem,
     qsystem_random,
@@ -17,6 +18,7 @@ from tket_exts import (
 BOOL_EXTENSION = opaque_bool()
 DEBUG_EXTENSION = debug()
 FUTURES_EXTENSION = futures()
+GUPPY_EXTENSION = guppy()
 QSYSTEM_EXTENSION = qsystem()
 QSYSTEM_RANDOM_EXTENSION = qsystem_random()
 QSYSTEM_UTILS_EXTENSION = qsystem_utils()
@@ -29,6 +31,7 @@ TKET_EXTENSIONS = [
     BOOL_EXTENSION,
     DEBUG_EXTENSION,
     FUTURES_EXTENSION,
+    GUPPY_EXTENSION,
     QSYSTEM_EXTENSION,
     QSYSTEM_RANDOM_EXTENSION,
     QSYSTEM_UTILS_EXTENSION,

guppylang_internals/tracing/builtins_mock.py

@@ -7,7 +7,8 @@ the builtins to avoid raising the `TypeError` in that case.
 """
 
 import builtins
-from collections.abc import Callable
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
 from typing import Any
 
 from guppylang_internals.tracing.object import GuppyObject, GuppyStructObject
@@ -46,10 +47,10 @@ class float(builtins.float, metaclass=_mock_meta(builtins.float)):  # type: igno
 
 
 class int(builtins.int, metaclass=_mock_meta(builtins.int)):  # type: ignore[misc]
-    def __new__(cls, x: Any = 0, /, **kwargs: Any) -> Any:
+    def __new__(cls, x: Any = 0, /, *args: Any, **kwargs: Any) -> Any:
         if isinstance(x, GuppyObject):
-            return x.__int__(**kwargs)
-        return builtins.int(x, **kwargs)
+            return x.__int__(*args, **kwargs)
+        return builtins.int(x, *args, **kwargs)
 
 
 def len(x: Any) -> Any:
@@ -58,5 +59,22 @@ def len(x: Any) -> Any:
     return builtins.len(x)
 
 
-def mock_builtins(f: Callable[..., Any]) -> None:
-    f.__globals__.update({"float": float, "int": int, "len": len})
+@contextmanager
+def mock_builtins(f: Callable[..., Any]) -> Iterator[None]:
+    # References to builtins inside `f` are looked up in `f.__builtins__`.
+    # Unfortunately, this is a readonly attribute so we can't assign a new dict to it.
+    # Mutating in-place is also a bad idea since this would also mutate the `builtins`
+    # module, making us loose an escape hatch to query the original. Instead, let's
+    # mutate `f.__globals__` which makes Python believe that the builtins are shadowed.
+    mock = {"float": float, "int": int, "len": len}
+    old = {x: f.__globals__[x] for x in mock if x in f.__globals__}
+    f.__globals__.update(mock)
+    try:
+        yield
+    finally:
+        # Reset back to the prior state since mutating `f.__globals__` also mutated the
+        # outer globals
+        for x in mock:
+            if x not in old:
+                del f.__globals__[x]
+        f.__globals__.update(old)

guppylang_internals/tracing/function.py

@@ -70,8 +70,7 @@ def trace_function(
             for wire, inp in zip(builder.inputs(), ty.inputs, strict=True)
         ]
 
-        with exception_hook(tracing_except_hook):
-            mock_builtins(python_func)
+        with exception_hook(tracing_except_hook), mock_builtins(python_func):
             py_out = python_func(*inputs)
 
         try:

{guppylang_internals-0.21.0.dist-info → guppylang_internals-0.21.2.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: guppylang-internals
-Version: 0.21.0
-Summary: Copmiler internals for `guppylang` package.
+Version: 0.21.2
+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>
 License:                                  Apache License

{guppylang_internals-0.21.0.dist-info → guppylang_internals-0.21.2.dist-info}/RECORD

@@ -1,13 +1,13 @@
-guppylang_internals/__init__.py,sha256=rfagOgIELmtxbgWxVGfxXBIFiBNWsBIL1-bp-l3ymKg,130
+guppylang_internals/__init__.py,sha256=lBdgf2-qLhtEr9FIbujNKmIcHIcyDf0li2vjfCwFyPo,130
 guppylang_internals/ast_util.py,sha256=I-SdMwi5cgSQRSV1C1RsBXeU2ovLEvvUpTzpoRwrIeE,11799
-guppylang_internals/decorator.py,sha256=lRAKbqsHpj6ZI5Z2rPjstTSaRvS7nnYY_CJkt5AS7L0,7991
+guppylang_internals/decorator.py,sha256=-A3Xml0uvS4DJGd138ZjdP9aiK_orHCaJpF8IR0JSu8,8742
 guppylang_internals/diagnostic.py,sha256=VCpIhyVD8KPtk0GDYMa8XH0lKVsRbsWNu_ucE2jQT2I,18395
-guppylang_internals/dummy_decorator.py,sha256=Z_jzVLxZYtTEh3I5h_1c18qKLb8PTef33PpF5FsGgL8,2161
+guppylang_internals/dummy_decorator.py,sha256=LXTXrdcrr55YzerX3qrHS23q6S9pVdpUAvhprWzKH6E,2330
 guppylang_internals/engine.py,sha256=KM3iY2gz5RrtEB44AWuz8P16Gk-ItDuUpsG9cDMtFyg,10251
 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=Lx2XP_PmIu3KSQaVcNZFP60MuewYho4o-i2Wp0JLJaQ,9614
+guppylang_internals/nodes.py,sha256=y9nlIiZIj1pfOEbBBveMkwuqmCfnfoqEBpGsGeMwQPc,10100
 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
@@ -18,10 +18,10 @@ guppylang_internals/cfg/cfg.py,sha256=q2mYWVyzl0-CVlQWcpjphyBqmS5zuRw-CiS2esa3Xk
 guppylang_internals/checker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/checker/cfg_checker.py,sha256=uye3h4zVV5056QOuUBS5MPrvh4wUbuNKV1LwETOStJk,14730
 guppylang_internals/checker/core.py,sha256=5c2X8AHwSBGQdk2eMiplhQ5lnl78bxQA2mJm3MFUty0,17675
-guppylang_internals/checker/expr_checker.py,sha256=9-fKPLNCbU7iiHq65KI1-qJTpS__zLHt7yTRK6JhXRc,58702
+guppylang_internals/checker/expr_checker.py,sha256=m9tCxVFjlM2YheFI3wp09dktb7rRFn9Blf5qLjBq2ms,58751
 guppylang_internals/checker/func_checker.py,sha256=zpYJ4vj6Xe0cmhF43ISV7rnRqGqel6jZQQfY8oFv9yU,10090
 guppylang_internals/checker/linearity_checker.py,sha256=cHvJSqFKWpkLqO7uAwz7OBmxtAi8ZN_K7afMrspkXy4,34719
-guppylang_internals/checker/stmt_checker.py,sha256=2wh7HNzCFwe9WjhV66XxWQ2wMJjze7L860o4aG_RU48,18123
+guppylang_internals/checker/stmt_checker.py,sha256=l-SNeep5pHvIr4ji4WwZBMwu56t_q2qA3SNbUAU4WoM,18848
 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
@@ -30,12 +30,12 @@ guppylang_internals/checker/errors/type_errors.py,sha256=1rEl8nVnveJXLc4CRKmNw2i
 guppylang_internals/checker/errors/wasm.py,sha256=tRpNhC8IZBkv6Nkn_dMRwGpDdZklv7UZdlYBu4WqI1A,874
 guppylang_internals/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/compiler/cfg_compiler.py,sha256=nGQmPYhXzicZ16_-8sgFC-sfLxMFEDSGd1Xf0j7LTK0,9039
-guppylang_internals/compiler/core.py,sha256=5Xitt3L8xwd3XKR_nRCU9fzEVRM9O31t8wnJd56IqKs,25405
-guppylang_internals/compiler/expr_compiler.py,sha256=wLUpKmrnj6EC22U_TNlo6LcXItDwfttNFjc3_IVzgNE,41230
+guppylang_internals/compiler/core.py,sha256=W1k_vQR3hePw97SQiR9mB2gxtMq_ht25eD4B7u93JNg,29000
+guppylang_internals/compiler/expr_compiler.py,sha256=KJyR22YjSz9ya3Ug_w4Esgnar3NOQ1zyLoWQR_e-s9E,41282
 guppylang_internals/compiler/func_compiler.py,sha256=0bo28RNsFZDYmllle-yFUXKC0UJsLl2TVjr3gvDMJVA,3377
 guppylang_internals/compiler/hugr_extension.py,sha256=eFUcxzBZoVzXV-AqEOJlh_rJkyuS3vFv1WKGOHjloJs,7966
 guppylang_internals/compiler/qtm_platform_extension.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-guppylang_internals/compiler/stmt_compiler.py,sha256=W1fDJiep7g-LLrNqjM64zXEXtDayDgmp2JczE7Sj5mw,8775
+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
@@ -45,7 +45,7 @@ guppylang_internals/definition/extern.py,sha256=0nk3a8oIqdh0-1n6_5aw7pNfExZwih3E
 guppylang_internals/definition/function.py,sha256=hOH-AD-jURjqIRjbYcKRAeFpxVvlPTI6N5pZT9khF2Y,10960
 guppylang_internals/definition/overloaded.py,sha256=UQ64waMp48gEVDCqEzuJFrRoNJ9saUIRUAynF3T-Gz8,5132
 guppylang_internals/definition/parameter.py,sha256=a5lKQejBuVYBd5Y6wSZLTO6wALB7Nn4kMwqrsCvYMvA,2699
-guppylang_internals/definition/pytket_circuits.py,sha256=5hte_xb80Q8k2TNSSg_zvNvmUhSW1rlL6WSmCxIvX-s,15428
+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
@@ -53,7 +53,7 @@ guppylang_internals/definition/value.py,sha256=tgkp-brIAauGXMqe68Fnwvz_bfdThdwJ_
 guppylang_internals/definition/wasm.py,sha256=RnaqySNRLsk-q3f8-NKIythnlLHF9TeZ2ivIHXq_JKo,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=g57lwQCRDMyUgRUDxCg1Afd06-O5w7vPki9C6GTiP3Q,23730
+guppylang_internals/std/_internal/checker.py,sha256=26GgGr2bBu6CAeWiYh-ggCz5rjOuL_ZJgbq1KwpZE4k,21731
 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
@@ -70,12 +70,12 @@ 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=d0JHB0kkUnktazJDoJAHU1uq8RQTZVyCksr2y6kxHC0,1410
+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/tracing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-guppylang_internals/tracing/builtins_mock.py,sha256=Cr3cwsElHD9L7mN2L4FXeG385hJo0Qqvt8sx30b9LYs,2087
+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=UTPEFfLLfRU5iNG0fLKpz0rs6QLSyP-gAVCgzDNyOos,7244
+guppylang_internals/tracing/function.py,sha256=sH7BHQrx0Hdq_4aYWwxXwN3ANfnTvhT-7re7mirelOQ,7233
 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
@@ -92,7 +92,7 @@ guppylang_internals/tys/printing.py,sha256=F60SZsvqDRNMQSbgNDfBDt2pYQH2ueaZo7Obm
 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.21.0.dist-info/METADATA,sha256=gz4Hmt44tr3TgBsL6WVhyEqIAG5x0T03dt3rg8KRqkg,14817
-guppylang_internals-0.21.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-guppylang_internals-0.21.0.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-guppylang_internals-0.21.0.dist-info/RECORD,,
+guppylang_internals-0.21.2.dist-info/METADATA,sha256=XPqewzNWXtMqb1qQ_MMt80-kgQqt7Pkqtys2MjmQv2c,14817
+guppylang_internals-0.21.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+guppylang_internals-0.21.2.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+guppylang_internals-0.21.2.dist-info/RECORD,,