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

guppylang_internals/std/_internal/checker.py

@@ -4,9 +4,9 @@ from typing import ClassVar
 
 from typing_extensions import assert_never
 
-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.ast_util import get_type, with_loc, with_type
+from guppylang_internals.checker.core import Context
+from guppylang_internals.checker.errors.generic import UnsupportedError
 from guppylang_internals.checker.errors.type_errors import (
     ArrayComprUnknownSizeError,
     TypeMismatchError,
@@ -33,8 +33,6 @@ from guppylang_internals.nodes import (
     GlobalCall,
     MakeIter,
     PanicExpr,
-    PlaceNode,
-    ResultExpr,
 )
 from guppylang_internals.tys.arg import ConstArg, TypeArg
 from guppylang_internals.tys.builtin import (
@@ -45,7 +43,6 @@ from guppylang_internals.tys.builtin import (
     get_iter_size,
     int_type,
     is_array_type,
-    is_bool_type,
     is_sized_iter_type,
     nat_type,
     sized_iter_type,
@@ -58,7 +55,6 @@ from guppylang_internals.tys.ty import (
     FunctionType,
     InputFlags,
     NoneType,
-    NumericType,
     Type,
     unify,
 )
@@ -302,80 +298,6 @@ class NewArrayChecker(CustomCallChecker):
         return with_loc(compr, array_compr), array_type(elt_ty, size)
 
 
-#: Maximum length of a tag in the `result` function.
-TAG_MAX_LEN = 200
-
-
-@dataclass(frozen=True)
-class TooLongError(Error):
-    title: ClassVar[str] = "Tag too long"
-    span_label: ClassVar[str] = "Result tag is too long"
-
-    @dataclass(frozen=True)
-    class Hint(Note):
-        message: ClassVar[str] = f"Result tags are limited to {TAG_MAX_LEN} bytes"
-
-
-class ResultChecker(CustomCallChecker):
-    """Call checker for the `result` function."""
-
-    @dataclass(frozen=True)
-    class InvalidError(Error):
-        title: ClassVar[str] = "Invalid Result"
-        span_label: ClassVar[str] = "Expression of type `{ty}` is not a valid result."
-        ty: Type
-
-        @dataclass(frozen=True)
-        class Explanation(Note):
-            message: ClassVar[str] = (
-                "Only numeric values or arrays thereof are allowed as results"
-            )
-
-    def synthesize(self, args: list[ast.expr]) -> tuple[ast.expr, Type]:
-        check_num_args(2, len(args), self.node)
-        [tag, value] = args
-        tag, _ = ExprChecker(self.ctx).check(tag, string_type())
-        match tag:
-            case ast.Constant(value=str(v)):
-                tag_value = v
-            case PlaceNode(place=ComptimeVariable(static_value=str(v))):
-                tag_value = v
-            case _:
-                raise GuppyTypeError(ExpectedError(tag, "a string literal"))
-        if len(tag_value.encode("utf-8")) > TAG_MAX_LEN:
-            err: Error = TooLongError(tag)
-            err.add_sub_diagnostic(TooLongError.Hint(None))
-            raise GuppyTypeError(err)
-        value, ty = ExprSynthesizer(self.ctx).synthesize(value)
-        # We only allow numeric values or vectors of numeric values
-        err = ResultChecker.InvalidError(value, ty)
-        err.add_sub_diagnostic(ResultChecker.InvalidError.Explanation(None))
-        if self._is_numeric_or_bool_type(ty):
-            base_ty = ty
-            array_len: Const | None = None
-        elif is_array_type(ty):
-            [ty_arg, len_arg] = ty.args
-            assert isinstance(ty_arg, TypeArg)
-            assert isinstance(len_arg, ConstArg)
-            if not self._is_numeric_or_bool_type(ty_arg.ty):
-                raise GuppyError(err)
-            base_ty = ty_arg.ty
-            array_len = len_arg.const
-        else:
-            raise GuppyError(err)
-        node = ResultExpr(value, base_ty, array_len, tag_value)
-        return with_loc(self.node, node), NoneType()
-
-    def check(self, args: list[ast.expr], ty: Type) -> tuple[ast.expr, Subst]:
-        expr, res_ty = self.synthesize(args)
-        expr, subst, _ = check_type_against(res_ty, ty, expr, self.ctx)
-        return expr, subst
-
-    @staticmethod
-    def _is_numeric_or_bool_type(ty: Type) -> bool:
-        return isinstance(ty, NumericType) or is_bool_type(ty)
-
-
 class PanicChecker(CustomCallChecker):
     """Call checker for the `panic`  function."""
 
@@ -395,18 +317,16 @@ class PanicChecker(CustomCallChecker):
                 err.add_sub_diagnostic(PanicChecker.NoMessageError.Suggestion(None))
                 raise GuppyTypeError(err)
             case [msg, *rest]:
+                # Check type of message and synthesize types for additional values.
                 msg, _ = ExprChecker(self.ctx).check(msg, string_type())
-                match msg:
-                    case ast.Constant(value=str(v)):
-                        msg_value = v
-                    case PlaceNode(place=ComptimeVariable(static_value=str(v))):
-                        msg_value = v
-                    case _:
-                        raise GuppyTypeError(ExpectedError(msg, "a string literal"))
                 vals = [ExprSynthesizer(self.ctx).synthesize(val)[0] for val in rest]
                 # TODO variable signals once default arguments are available
+                # TODO this will also allow us to remove this manual AST node hack
+                signal_expr = with_type(
+                    int_type(), with_loc(self.node, ast.Constant(value=1))
+                )
                 node = PanicExpr(
-                    kind=ExitKind.Panic, msg=msg_value, values=vals, signal=1
+                    kind=ExitKind.Panic, msg=msg, values=vals, signal=signal_expr
                 )
                 return with_loc(self.node, node), NoneType()
             case args:
@@ -454,31 +374,16 @@ class ExitChecker(CustomCallChecker):
                 )
                 raise GuppyTypeError(signal_err)
             case [msg, signal, *rest]:
+                # Check types for message and signal and synthesize types for additional
+                # values.
                 msg, _ = ExprChecker(self.ctx).check(msg, string_type())
-                match msg:
-                    case ast.Constant(value=str(v)):
-                        msg_value = v
-                    case PlaceNode(place=ComptimeVariable(static_value=str(v))):
-                        msg_value = v
-                    case _:
-                        raise GuppyTypeError(ExpectedError(msg, "a string literal"))
-                # TODO allow variable signals after https://github.com/CQCL/hugr/issues/1863
                 signal, _ = ExprChecker(self.ctx).check(signal, int_type())
-                match signal:
-                    case ast.Constant(value=int(s)):
-                        signal_value = s
-                    case PlaceNode(place=ComptimeVariable(static_value=int(s))):
-                        signal_value = s
-                    case _:
-                        raise GuppyTypeError(
-                            ExpectedError(signal, "an integer literal")
-                        )
                 vals = [ExprSynthesizer(self.ctx).synthesize(val)[0] for val in rest]
                 node = PanicExpr(
                     kind=ExitKind.ExitShot,
-                    msg=msg_value,
+                    msg=msg,
                     values=vals,
-                    signal=signal_value,
+                    signal=signal,
                 )
                 return with_loc(self.node, node), NoneType()
             case args:

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 --------
 # ------------------------------------------------------
@@ -233,17 +261,12 @@ class NewArrayCompiler(ArrayCompiler):
 
     def build_classical_array(self, elems: list[Wire]) -> Wire:
         """Lowers a call to `array.__new__` for classical arrays."""
-        # See https://github.com/CQCL/guppylang/issues/629
+        # See https://github.com/quantinuum/guppylang/issues/629
         return self.build_linear_array(elems)
 
     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, array: Wire, idx: Wire) -> CallReturnWires:
+        """Constructs `__getitem__` for classical arrays."""
+        idx = self.builder.add_op(convert_itousize(), idx)
 
-    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())
-
-        # 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