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

guppylang_internals/std/_internal/compiler/array.py

@@ -2,31 +2,23 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Final, TypeVar
+from typing import TYPE_CHECKING, TypeVar
 
 import hugr
 from hugr import Wire, ops
 from hugr import tys as ht
-from hugr.std.collections.value_array import EXTENSION
+from hugr.std.collections.borrow_array import EXTENSION
 
-from guppylang_internals.compiler.core import (
-    GlobalConstId,
-)
 from guppylang_internals.definition.custom import CustomCallCompiler
 from guppylang_internals.definition.value import CallReturnWires
 from guppylang_internals.error import InternalGuppyError
 from guppylang_internals.std._internal.compiler.arithmetic import convert_itousize
 from guppylang_internals.std._internal.compiler.prelude import (
-    build_expect_none,
-    build_unwrap,
-    build_unwrap_left,
     build_unwrap_right,
 )
 from guppylang_internals.tys.arg import ConstArg, TypeArg
-from guppylang_internals.tys.builtin import int_type
 
 if TYPE_CHECKING:
-    from hugr.build import function as hf
     from hugr.build.dfg import DfBase
 
 
@@ -50,10 +42,10 @@ def _instantiate_array_op(
 def array_type(elem_ty: ht.Type, length: ht.TypeArg) -> ht.ExtType:
     """Returns the hugr type of a fixed length array.
 
-    This is the copyable `value_array` type used by Guppy.
+    This is the linear `borrow_array` type used by Guppy.
     """
     elem_arg = ht.TypeTypeArg(elem_ty)
-    return EXTENSION.types["value_array"].instantiate([length, elem_arg])
+    return EXTENSION.types["borrow_array"].instantiate([length, elem_arg])
 
 
 def standard_array_type(elem_ty: ht.Type, length: ht.TypeArg) -> ht.ExtType:
@@ -162,9 +154,9 @@ def array_repeat(elem_ty: ht.Type, length: ht.TypeArg) -> ops.ExtOp:
     )
 
 
-def array_convert_to_std_array(elem_ty: ht.Type, length: ht.TypeArg) -> ops.ExtOp:
-    """Returns an array operation to convert the `value_array` type used by Guppy into
-    the regular linear `array` in Hugr.
+def array_to_std_array(elem_ty: ht.Type, length: ht.TypeArg) -> ops.ExtOp:
+    """Returns an array operation to convert a value of the `borrow_array` type
+    used by Guppy into a standard `array`.
     """
     return EXTENSION.get_op("to_array").instantiate(
         [length, ht.TypeTypeArg(elem_ty)],
@@ -174,9 +166,9 @@ def array_convert_to_std_array(elem_ty: ht.Type, length: ht.TypeArg) -> ops.ExtO
     )
 
 
-def array_convert_from_std_array(elem_ty: ht.Type, length: ht.TypeArg) -> ops.ExtOp:
-    """Returns an array operation to convert the `array` type used by Hugr into the
-    `value_array` type used by Guppy.
+def std_array_to_array(elem_ty: ht.Type, length: ht.TypeArg) -> ops.ExtOp:
+    """Returns an array operation to convert the standard `array` type into the
+    `borrow_array` type used by Guppy.
     """
     return EXTENSION.get_op("from_array").instantiate(
         [length, ht.TypeTypeArg(elem_ty)],
@@ -186,6 +178,42 @@ def array_convert_from_std_array(elem_ty: ht.Type, length: ht.TypeArg) -> ops.Ex
     )
 
 
+def barray_borrow(elem_ty: ht.Type, length: ht.TypeArg) -> ops.ExtOp:
+    """Returns an array `borrow` operation."""
+    arr_ty = array_type(elem_ty, length)
+    return _instantiate_array_op(
+        "borrow", elem_ty, length, [arr_ty, ht.USize()], [arr_ty, elem_ty]
+    )
+
+
+def barray_return(elem_ty: ht.Type, length: ht.TypeArg) -> ops.ExtOp:
+    """Returns an array `return` operation."""
+    arr_ty = array_type(elem_ty, length)
+    return _instantiate_array_op(
+        "return", elem_ty, length, [arr_ty, ht.USize(), elem_ty], [arr_ty]
+    )
+
+
+def barray_discard_all_borrowed(elem_ty: ht.Type, length: ht.TypeArg) -> ops.ExtOp:
+    """Returns an array `discard_all_borrowed` operation."""
+    arr_ty = array_type(elem_ty, length)
+    return _instantiate_array_op("discard_all_borrowed", elem_ty, length, [arr_ty], [])
+
+
+def barray_new_all_borrowed(elem_ty: ht.Type, length: ht.TypeArg) -> ops.ExtOp:
+    """Returns an array `new_all_borrowed` operation."""
+    arr_ty = array_type(elem_ty, length)
+    return _instantiate_array_op("new_all_borrowed", elem_ty, length, [], [arr_ty])
+
+
+def array_clone(elem_ty: ht.Type, length: ht.TypeArg) -> ops.ExtOp:
+    """Returns an array `clone` operation for arrays none of whose elements are
+    borrowed."""
+    assert elem_ty.type_bound() == ht.TypeBound.Copyable
+    arr_ty = array_type(elem_ty, length)
+    return _instantiate_array_op("clone", elem_ty, length, [arr_ty], [arr_ty, arr_ty])
+
+
 # ------------------------------------------------------
 # --------- Custom compilers for non-native ops --------
 # ------------------------------------------------------
@@ -238,12 +266,7 @@ class NewArrayCompiler(ArrayCompiler):
 
     def build_linear_array(self, elems: list[Wire]) -> Wire:
         """Lowers a call to `array.__new__` for linear arrays."""
-        elem_opts = [
-            self.builder.add_op(ops.Some(self.elem_ty), elem) for elem in elems
-        ]
-        return self.builder.add_op(
-            array_new(ht.Option(self.elem_ty), len(elems)), *elem_opts
-        )
+        return self.builder.add_op(array_new(self.elem_ty, len(elems)), *elems)
 
     def compile(self, args: list[Wire]) -> list[Wire]:
         if self.elem_ty.type_bound() == ht.TypeBound.Linear:
@@ -252,131 +275,35 @@ class NewArrayCompiler(ArrayCompiler):
             return [self.build_classical_array(args)]
 
 
-ARRAY_GETITEM_CLASSICAL: Final[GlobalConstId] = GlobalConstId.fresh(
-    "array.__getitem__.classical"
-)
-ARRAY_GETITEM_LINEAR: Final[GlobalConstId] = GlobalConstId.fresh(
-    "array.__getitem__.linear"
-)
-ARRAY_SETITEM_CLASSICAL: Final[GlobalConstId] = GlobalConstId.fresh(
-    "array.__setitem__.classical"
-)
-ARRAY_SETITEM_LINEAR: Final[GlobalConstId] = GlobalConstId.fresh(
-    "array.__setitem__.linear"
-)
-ARRAY_ITER_ASSERT_ALL_USED_HELPER: Final[GlobalConstId] = GlobalConstId.fresh(
-    "ArrayIter._assert_all_used.helper"
-)
-
-
 class ArrayGetitemCompiler(ArrayCompiler):
     """Compiler for the `array.__getitem__` function."""
 
-    def _getitem_ty(self, bound: ht.TypeBound) -> ht.PolyFuncType:
-        """Constructs a polymorphic function type for `__getitem__`"""
-        # a(Option(T), N), int -> T, a(Option(T), N)
-        # Array element type parameter
-        elem_ty_param = ht.TypeTypeParam(bound)
-        # Array length parameter
-        length_param = ht.BoundedNatParam()
-        return ht.PolyFuncType(
-            params=[elem_ty_param, length_param],
-            body=ht.FunctionType(
-                input=[
-                    array_type(
-                        ht.Option(ht.Variable(0, bound)),
-                        ht.VariableArg(1, length_param),
-                    ),
-                    int_type().to_hugr(self.ctx),
-                ],
-                output=[
-                    ht.Variable(0, bound),
-                    array_type(
-                        ht.Option(ht.Variable(0, bound)),
-                        ht.VariableArg(1, length_param),
-                    ),
-                ],
-            ),
-        )
-
-    def _build_classical_getitem(self, func: hf.Function) -> None:
-        """Constructs a generic function for `__getitem__` for classical arrays."""
-        elem_ty = ht.Variable(0, ht.TypeBound.Copyable)
-        length = ht.VariableArg(1, ht.BoundedNatParam())
+    def _build_classical_getitem(self, array: Wire, idx: Wire) -> CallReturnWires:
+        """Constructs `__getitem__` for classical arrays."""
+        idx = self.builder.add_op(convert_itousize(), idx)
 
-        # See https://github.com/CQCL/guppylang/issues/629
-        elem_opt_ty = ht.Option(elem_ty)
-        none = func.add_op(ops.Tag(0, elem_opt_ty))
-        idx = func.add_op(convert_itousize(), func.inputs()[1])
-        # As copyable elements can be used multiple times, we need to swap the element
-        # back after initially swapping it out for `None` to get the value.
-        initial_result = func.add_op(
-            array_set(elem_opt_ty, length),
-            func.inputs()[0],
-            idx,
-            none,
-        )
-        elem_opt, arr = build_unwrap_right(
-            func, initial_result, "Array index out of bounds"
-        )
-        swapped_back = func.add_op(
-            array_set(elem_opt_ty, length),
-            arr,
-            idx,
-            elem_opt,
-        )
-        _, arr = build_unwrap_right(func, swapped_back, "Array index out of bounds")
-        elem = build_unwrap(func, elem_opt, "array.__getitem__: Internal error")
-
-        func.set_outputs(elem, arr)
-
-    def _build_linear_getitem(self, func: hf.Function) -> None:
-        """Constructs function to call `array.__getitem__` for linear arrays."""
-        elem_ty = ht.Variable(0, ht.TypeBound.Linear)
-        length = ht.VariableArg(1, ht.BoundedNatParam())
-
-        elem_opt_ty = ht.Option(elem_ty)
-        none = func.add_op(ops.Tag(0, elem_opt_ty))
-        idx = func.add_op(convert_itousize(), func.inputs()[1])
-        result = func.add_op(
-            array_set(elem_opt_ty, length),
-            func.inputs()[0],
+        opt_elem, arr = self.builder.add_op(
+            array_get(self.elem_ty, self.length),
+            array,
             idx,
-            none,
         )
-        elem_opt, array = build_unwrap_right(func, result, "Array index out of bounds")
-        elem = build_unwrap(
-            func, elem_opt, "Linear array element has already been used"
+        elem = build_unwrap_right(self.builder, opt_elem, "Array index out of bounds")
+        return CallReturnWires(
+            regular_returns=[elem],
+            inout_returns=[arr],
         )
 
-        func.set_outputs(elem, array)
-
-    def _build_call_getitem(
-        self,
-        func: hf.Function,
-        array: Wire,
-        idx: Wire,
-    ) -> CallReturnWires:
-        """Inserts a call to `array.__getitem__`."""
-        concrete_func_ty = ht.FunctionType(
-            input=[
-                array_type(ht.Option(self.elem_ty), self.length),
-                int_type().to_hugr(self.ctx),
-            ],
-            output=[self.elem_ty, array_type(ht.Option(self.elem_ty), self.length)],
-        )
-        type_args = [ht.TypeTypeArg(self.elem_ty), self.length]
-        func_call = self.builder.call(
-            func.parent_node,
+    def _build_linear_getitem(self, array: Wire, idx: Wire) -> CallReturnWires:
+        """Constructs `array.__getitem__` for linear arrays."""
+        idx = self.builder.add_op(convert_itousize(), idx)
+        arr, elem = self.builder.add_op(
+            barray_borrow(self.elem_ty, self.length),
             array,
             idx,
-            instantiation=concrete_func_ty,
-            type_args=type_args,
         )
-        outputs = list(func_call.outputs())
         return CallReturnWires(
-            regular_returns=[outputs[0]],
-            inout_returns=[outputs[1]],
+            regular_returns=[elem],
+            inout_returns=[arr],
         )
 
     def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
@@ -384,24 +311,9 @@ class ArrayGetitemCompiler(ArrayCompiler):
         [elem_ty_arg, _] = self.type_args
         assert isinstance(elem_ty_arg, TypeArg)
         if not elem_ty_arg.ty.copyable:
-            func_ty = self._getitem_ty(ht.TypeBound.Linear)
-            func, already_exists = self.ctx.declare_global_func(
-                ARRAY_GETITEM_LINEAR, func_ty
-            )
-            if not already_exists:
-                self._build_linear_getitem(func)
+            return self._build_linear_getitem(array, idx)
         else:
-            func_ty = self._getitem_ty(ht.TypeBound.Copyable)
-            func, already_exists = self.ctx.declare_global_func(
-                ARRAY_GETITEM_CLASSICAL, func_ty
-            )
-            if not already_exists:
-                self._build_classical_getitem(func)
-        return self._build_call_getitem(
-            func=func,
-            array=array,
-            idx=idx,
-        )
+            return self._build_classical_getitem(array, idx)
 
     def compile(self, args: list[Wire]) -> list[Wire]:
         raise InternalGuppyError("Call compile_with_inouts instead")
@@ -410,160 +322,60 @@ class ArrayGetitemCompiler(ArrayCompiler):
 class ArraySetitemCompiler(ArrayCompiler):
     """Compiler for the `array.__setitem__` function."""
 
-    def _setitem_ty(self, bound: ht.TypeBound) -> ht.PolyFuncType:
-        """Constructs a polymorphic function type for `__setitem__`"""
-        # a(Option(T), N), int, T -> a(Option(T), N)
-        elem_ty_param = ht.TypeTypeParam(bound)
-        length_param = ht.BoundedNatParam()
-        return ht.PolyFuncType(
-            params=[elem_ty_param, length_param],
-            body=ht.FunctionType(
-                input=[
-                    array_type(
-                        ht.Option(ht.Variable(0, bound)),
-                        ht.VariableArg(1, length_param),
-                    ),
-                    int_type().to_hugr(self.ctx),
-                    ht.Variable(0, bound),
-                ],
-                output=[
-                    array_type(
-                        ht.Option(ht.Variable(0, bound)),
-                        ht.VariableArg(1, length_param),
-                    ),
-                ],
-            ),
-        )
-
-    def _build_classical_setitem(self, func: hf.Function) -> None:
-        """Constructs a generic function for `__setitem__` for classical arrays."""
-        elem_ty = ht.Variable(0, ht.TypeBound.Copyable)
-        length = ht.VariableArg(1, ht.BoundedNatParam())
-
-        elem_opt_ty = ht.Option(elem_ty)
-        idx = func.add_op(convert_itousize(), func.inputs()[1])
-        elem_opt = func.add_op(ops.Some(elem_ty), func.inputs()[2])
-        result = func.add_op(
-            array_set(elem_opt_ty, length),
-            func.inputs()[0],
-            idx,
-            elem_opt,
-        )
-        _, array = build_unwrap_right(func, result, "Array index out of bounds")
-
-        func.set_outputs(array)
-
-    def _build_linear_setitem(self, func: hf.Function) -> None:
-        """Constructs function to call `array.__setitem__` for linear arrays."""
-        elem_ty = ht.Variable(0, ht.TypeBound.Linear)
-        length = ht.VariableArg(1, ht.BoundedNatParam())
-
-        elem_opt_ty = ht.Option(elem_ty)
-        elem = func.add_op(ops.Some(elem_ty), func.inputs()[2])
-        idx = func.add_op(convert_itousize(), func.inputs()[1])
-        result = func.add_op(
-            array_set(elem_opt_ty, length),
-            func.inputs()[0],
+    def _build_classical_setitem(
+        self, array: Wire, idx: Wire, elem: Wire
+    ) -> CallReturnWires:
+        """Constructs `__setitem__` for classical arrays."""
+        idx = self.builder.add_op(convert_itousize(), idx)
+        result = self.builder.add_op(
+            array_set(self.elem_ty, self.length),
+            array,
             idx,
             elem,
         )
-        old_elem_opt, array = build_unwrap_right(
-            func, result, "Array index out of bounds"
-        )
-        build_unwrap_left(func, old_elem_opt, "Linear array element has not been used")
+        _, arr = build_unwrap_right(self.builder, result, "Array index out of bounds")
 
-        func.set_outputs(array)
+        return CallReturnWires(
+            regular_returns=[],
+            inout_returns=[arr],
+        )
 
-    def _build_call_setitem(
-        self,
-        func: hf.Function,
-        array: Wire,
-        idx: Wire,
-        elem: Wire,
+    def _build_linear_setitem(
+        self, array: Wire, idx: Wire, elem: Wire
     ) -> CallReturnWires:
-        """Inserts a call to `array.__setitem__`."""
-        concrete_func_ty = ht.FunctionType(
-            input=[
-                array_type(ht.Option(self.elem_ty), self.length),
-                int_type().to_hugr(self.ctx),
-                self.elem_ty,
-            ],
-            output=[array_type(ht.Option(self.elem_ty), self.length)],
-        )
-        type_args = [ht.TypeTypeArg(self.elem_ty), self.length]
-        func_call = self.builder.call(
-            func.parent_node,
+        """Constructs `array.__setitem__` for linear arrays."""
+        idx = self.builder.add_op(convert_itousize(), idx)
+        arr = self.builder.add_op(
+            barray_return(self.elem_ty, self.length),
             array,
             idx,
             elem,
-            instantiation=concrete_func_ty,
-            type_args=type_args,
         )
+
         return CallReturnWires(
             regular_returns=[],
-            inout_returns=list(func_call.outputs()),
+            inout_returns=[arr],
         )
 
     def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
         [array, idx, elem] = args
         if self.elem_ty.type_bound() == ht.TypeBound.Linear:
-            func_ty = self._setitem_ty(ht.TypeBound.Linear)
-            func, already_exists = self.ctx.declare_global_func(
-                ARRAY_SETITEM_LINEAR, func_ty
-            )
-            if not already_exists:
-                self._build_linear_setitem(func)
+            return self._build_linear_setitem(array, idx, elem)
         else:
-            func_ty = self._setitem_ty(ht.TypeBound.Copyable)
-            func, already_exists = self.ctx.declare_global_func(
-                ARRAY_SETITEM_CLASSICAL, func_ty
-            )
-            if not already_exists:
-                self._build_classical_setitem(func)
-        return self._build_call_setitem(func=func, array=array, idx=idx, elem=elem)
+            return self._build_classical_setitem(array, idx, elem)
 
     def compile(self, args: list[Wire]) -> list[Wire]:
         raise InternalGuppyError("Call compile_with_inouts instead")
 
 
-class ArrayIterAsertAllUsedCompiler(ArrayCompiler):
-    """Compiler for the `ArrayIter._assert_all_used` method."""
+class ArrayDiscardAllUsedCompiler(ArrayCompiler):
+    """Compiler for the `_array_discard_all_used` method."""
 
     def compile(self, args: list[Wire]) -> list[Wire]:
-        # For linear array iterators, map the array of optional elements to an
-        # `array[None, n]` that we can discard.
         if self.elem_ty.type_bound() == ht.TypeBound.Linear:
-            elem_opt_ty = ht.Option(self.elem_ty)
-            unit_ty = ht.UnitSum(1)
-            # Instantiate `unwrap_none` function
-            func = self.builder.load_function(
-                self.define_unwrap_none_helper(),
-                type_args=[ht.TypeTypeArg(self.elem_ty)],
-                instantiation=ht.FunctionType([elem_opt_ty], [unit_ty]),
-            )
-            # Map it over the array so that the resulting array is no longer linear and
-            # can be discarded
-            [array_iter] = args
-            array, _ = self.builder.add_op(ops.UnpackTuple(), array_iter)
+            [arr] = args
             self.builder.add_op(
-                array_map(elem_opt_ty, self.length, unit_ty), array, func
+                barray_discard_all_borrowed(self.elem_ty, self.length),
+                arr,
             )
         return []
-
-    def define_unwrap_none_helper(self) -> hf.Function:
-        """Define an `unwrap_none` function that checks that the passed element is
-        indeed `None`."""
-        opt_ty = ht.Option(ht.Variable(0, ht.TypeBound.Linear))
-        unit_ty = ht.UnitSum(1)
-        func_ty = ht.PolyFuncType(
-            params=[ht.TypeTypeParam(ht.TypeBound.Linear)],
-            body=ht.FunctionType([opt_ty], [unit_ty]),
-        )
-        func, already_defined = self.ctx.declare_global_func(
-            ARRAY_ITER_ASSERT_ALL_USED_HELPER, func_ty
-        )
-        if not already_defined:
-            err_msg = "ArrayIter._assert_all_used: array element has not been used"
-            build_expect_none(func, func.inputs()[0], err_msg)
-            func.set_outputs(func.add_op(ops.MakeTuple()))
-        return func

guppylang_internals/std/_internal/compiler/tket_exts.py

@@ -1,11 +1,13 @@
 from dataclasses import dataclass
 
+import tket_exts
 from hugr import val
 from tket_exts import (
     debug,
     futures,
+    global_phase,
     guppy,
-    opaque_bool,
+    modifier,
     qsystem,
     qsystem_random,
     qsystem_utils,
@@ -15,10 +17,11 @@ from tket_exts import (
     wasm,
 )
 
-BOOL_EXTENSION = opaque_bool()
+BOOL_EXTENSION = tket_exts.bool()
 DEBUG_EXTENSION = debug()
 FUTURES_EXTENSION = futures()
 GUPPY_EXTENSION = guppy()
+MODIFIER_EXTENSION = modifier()
 QSYSTEM_EXTENSION = qsystem()
 QSYSTEM_RANDOM_EXTENSION = qsystem_random()
 QSYSTEM_UTILS_EXTENSION = qsystem_utils()
@@ -26,6 +29,8 @@ QUANTUM_EXTENSION = quantum()
 RESULT_EXTENSION = result()
 ROTATION_EXTENSION = rotation()
 WASM_EXTENSION = wasm()
+MODIFIER_EXTENSION = modifier()
+GLOBAL_PHASE_EXTENSION = global_phase()
 
 TKET_EXTENSIONS = [
     BOOL_EXTENSION,
@@ -39,6 +44,8 @@ TKET_EXTENSIONS = [
     RESULT_EXTENSION,
     ROTATION_EXTENSION,
     WASM_EXTENSION,
+    MODIFIER_EXTENSION,
+    GLOBAL_PHASE_EXTENSION,
 ]
 
 

guppylang_internals/tracing/unpacking.py

@@ -1,7 +1,6 @@
 from typing import Any, TypeVar
 
 from hugr import ops
-from hugr import tys as ht
 from hugr.build.dfg import DfBase
 
 from guppylang_internals.ast_util import AstNode
@@ -13,7 +12,6 @@ from guppylang_internals.compiler.core import CompilerContext
 from guppylang_internals.compiler.expr_compiler import python_value_to_hugr
 from guppylang_internals.error import GuppyComptimeError, GuppyError
 from guppylang_internals.std._internal.compiler.array import array_new, unpack_array
-from guppylang_internals.std._internal.compiler.prelude import build_unwrap
 from guppylang_internals.tracing.frozenlist import frozenlist
 from guppylang_internals.tracing.object import (
     GuppyObject,
@@ -71,9 +69,7 @@ def unpack_guppy_object(
                     # them as Guppy objects here
                     return obj
                 elem_ty = get_element_type(ty)
-                opt_elems = unpack_array(builder, obj._use_wire(None))
-                err = "Non-copyable array element has already been used"
-                elems = [build_unwrap(builder, opt_elem, err) for opt_elem in opt_elems]
+                elems = unpack_array(builder, obj._use_wire(None))
                 obj_list = [
                     unpack_guppy_object(GuppyObject(elem_ty, wire), builder, frozen)
                     for wire in elems
@@ -128,11 +124,8 @@ def guppy_object_from_py(
                         f"Element at index {i + 1} does not match the type of "
                         f"previous elements. Expected `{elem_ty}`, got `{obj._ty}`."
                     )
-            hugr_elem_ty = ht.Option(elem_ty.to_hugr(ctx))
-            wires = [
-                builder.add_op(ops.Tag(1, hugr_elem_ty), obj._use_wire(None))
-                for obj in objs
-            ]
+            hugr_elem_ty = elem_ty.to_hugr(ctx)
+            wires = [obj._use_wire(None) for obj in objs]
             return GuppyObject(
                 array_type(elem_ty, len(vs)),
                 builder.add_op(array_new(hugr_elem_ty, len(vs)), *wires),
@@ -172,26 +165,32 @@ def update_packed_value(v: Any, obj: "GuppyObject", builder: DfBase[P]) -> bool:
             assert isinstance(obj._ty, NoneType)
         case tuple(vs):
             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):
-                success = update_packed_value(v, GuppyObject(ty, wire), builder)
+            wire_iterator = builder.add_op(
+                ops.UnpackTuple(), obj._use_wire(None)
+            ).outputs()
+            for v, ty, out_wire in zip(
+                vs, obj._ty.element_types, wire_iterator, strict=True
+            ):
+                success = update_packed_value(v, GuppyObject(ty, out_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):
+            wire_iterator = builder.add_op(
+                ops.UnpackTuple(), obj._use_wire(None)
+            ).outputs()
+            for field, out_wire in zip(ty.fields, wire_iterator, strict=True):
                 v = values[field.name]
-                success = update_packed_value(v, GuppyObject(field.ty, wire), builder)
+                success = update_packed_value(
+                    v, GuppyObject(field.ty, out_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 i, (v, opt_wire) in enumerate(zip(vs, opt_wires, strict=True)):
-                (wire,) = build_unwrap(builder, opt_wire, err).outputs()
+            wires = unpack_array(builder, obj._use_wire(None))
+            for i, (v, wire) in enumerate(zip(vs, wires, strict=True)):
                 success = update_packed_value(v, GuppyObject(elem_ty, wire), builder)
                 if not success:
                     vs[i] = obj

guppylang_internals/tys/arg.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, TypeAlias
 
 from hugr import tys as ht
@@ -18,7 +18,7 @@ from guppylang_internals.tys.const import (
     ConstValue,
     ExistentialConstVar,
 )
-from guppylang_internals.tys.var import ExistentialVar
+from guppylang_internals.tys.var import BoundVar, ExistentialVar
 
 if TYPE_CHECKING:
     from guppylang_internals.tys.ty import Type
@@ -45,19 +45,29 @@ class ArgumentBase(ToHugr[ht.TypeArg], Transformable["Argument"], ABC):
     def unsolved_vars(self) -> set[ExistentialVar]:
         """The existential type variables contained in this argument."""
 
+    @property
+    @abstractmethod
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this argument."""
+
 
 @dataclass(frozen=True)
 class TypeArg(ArgumentBase):
     """Argument that can be instantiated for a `TypeParameter`."""
 
     # The type to instantiate
-    ty: "Type"
+    ty: "Type" = field(hash=False)  # Types are not hashable
 
     @property
     def unsolved_vars(self) -> set[ExistentialVar]:
         """The existential type variables contained in this argument."""
         return self.ty.unsolved_vars
 
+    @property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this type."""
+        return self.ty.bound_vars
+
     def to_hugr(self, ctx: ToHugrContext) -> ht.TypeTypeArg:
         """Computes the Hugr representation of the argument."""
         ty: ht.Type = self.ty.to_hugr(ctx)
@@ -84,6 +94,11 @@ class ConstArg(ArgumentBase):
         """The existential const variables contained in this argument."""
         return self.const.unsolved_vars
 
+    @property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this argument."""
+        return self.const.bound_vars
+
     def to_hugr(self, ctx: ToHugrContext) -> ht.TypeArg:
         """Computes the Hugr representation of this argument."""
         from guppylang_internals.tys.ty import NumericType