guppylang-internals 0.21.0__py3-none-any.whl

guppylang_internals/std/_internal/compiler/either.py

@@ -0,0 +1,131 @@
+from abc import ABC
+from collections.abc import Sequence
+
+from hugr import Wire, ops
+from hugr import tys as ht
+
+from guppylang_internals.definition.custom import (
+    CustomCallCompiler,
+    CustomInoutCallCompiler,
+)
+from guppylang_internals.definition.value import CallReturnWires
+from guppylang_internals.error import InternalGuppyError
+from guppylang_internals.std._internal.compiler.prelude import (
+    build_unwrap_left,
+    build_unwrap_right,
+)
+from guppylang_internals.std._internal.compiler.tket_bool import (
+    OPAQUE_FALSE,
+    OPAQUE_TRUE,
+)
+from guppylang_internals.tys.arg import Argument, TypeArg
+from guppylang_internals.tys.common import ToHugrContext
+from guppylang_internals.tys.ty import type_to_row
+
+
+def either_to_hugr(type_args: Sequence[Argument], ctx: ToHugrContext) -> ht.Either:
+    match type_args:
+        case [TypeArg(left_ty), TypeArg(right_ty)]:
+            left_tys = [ty.to_hugr(ctx) for ty in type_to_row(left_ty)]
+            right_tys = [ty.to_hugr(ctx) for ty in type_to_row(right_ty)]
+            return ht.Either(left_tys, right_tys)
+        case _:
+            raise InternalGuppyError("Invalid type args for Either type")
+
+
+class EitherCompiler(CustomInoutCallCompiler, ABC):
+    """Abstract base class for compilers for `Either` methods."""
+
+    @property
+    def left_tys(self) -> list[ht.Type]:
+        match self.type_args:
+            case [TypeArg(left_ty), TypeArg()]:
+                return [ty.to_hugr(self.ctx) for ty in type_to_row(left_ty)]
+            case _:
+                raise InternalGuppyError("Invalid type args for Either op")
+
+    @property
+    def right_tys(self) -> list[ht.Type]:
+        match self.type_args:
+            case [TypeArg(), TypeArg(right_ty)]:
+                return [ty.to_hugr(self.ctx) for ty in type_to_row(right_ty)]
+            case _:
+                raise InternalGuppyError("Invalid type args for Either op")
+
+    @property
+    def either_ty(self) -> ht.Either:
+        return either_to_hugr(self.type_args, self.ctx)
+
+
+class EitherConstructor(EitherCompiler, CustomCallCompiler):
+    """Compiler for the `Option` constructors `nothing` and `some`."""
+
+    def __init__(self, tag: int):
+        self.tag = tag
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        ty = self.either_ty
+        if self.tag == 1:
+            # In the `right` case, the type args are swapped around since `R` occurs
+            # first in the signature :(
+            ty.variant_rows = [ty.variant_rows[1], ty.variant_rows[0]]
+        return [self.builder.add_op(ops.Tag(self.tag, ty), *args)]
+
+
+class EitherTestCompiler(EitherCompiler):
+    """Compiler for the `Either.is_left` and `Either.is_right` methods."""
+
+    def __init__(self, tag: int):
+        self.tag = tag
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        [either] = args
+        cond = self.builder.add_conditional(either)
+        for i in [0, 1]:
+            with cond.add_case(i) as case:
+                val = OPAQUE_TRUE if i == self.tag else OPAQUE_FALSE
+                either = case.add_op(ops.Tag(i, self.either_ty), *case.inputs())
+                case.set_outputs(case.load(val), either)
+        [res, either] = cond.outputs()
+        return CallReturnWires(regular_returns=[res], inout_returns=[either])
+
+
+class EitherToOptionCompiler(EitherCompiler, CustomCallCompiler):
+    """Compiler for the `Either.left` and `Either.right` methods."""
+
+    def __init__(self, tag: int):
+        self.tag = tag
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        [either] = args
+        cond = self.builder.add_conditional(either)
+        target_tys = self.left_tys if self.tag == 0 else self.right_tys
+        for i in [0, 1]:
+            with cond.add_case(i) as case:
+                if i == self.tag:
+                    out = case.add_op(
+                        ops.Tag(1, ht.Option(*target_tys)), *case.inputs()
+                    )
+                else:
+                    out = case.add_op(ops.Tag(0, ht.Option(*target_tys)))
+                case.set_outputs(out)
+        return list(cond.outputs())
+
+
+class EitherUnwrapCompiler(EitherCompiler, CustomCallCompiler):
+    """Compiler for the `Either.unwrap_left` and `Either.unwrap_right` methods."""
+
+    def __init__(self, tag: int):
+        self.tag = tag
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        [either] = args
+        if self.tag == 0:
+            out = build_unwrap_left(
+                self.builder, either, "Either.unwrap_left: value is `right`"
+            )
+        else:
+            out = build_unwrap_right(
+                self.builder, either, "Either.unwrap_right: value is `left`"
+            )
+        return list(out)

guppylang_internals/std/_internal/compiler/frozenarray.py

@@ -0,0 +1,68 @@
+"""Compilers building frozenarray functions on top of hugr standard operations."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Final
+
+from hugr import Wire, ops
+from hugr import tys as ht
+from hugr.std.collections.static_array import EXTENSION, StaticArray
+
+from guppylang_internals.compiler.core import (
+    GlobalConstId,
+)
+from guppylang_internals.definition.custom import CustomCallCompiler
+from guppylang_internals.std._internal.compiler.arithmetic import (
+    INT_T,
+    convert_itousize,
+)
+from guppylang_internals.std._internal.compiler.prelude import (
+    build_unwrap,
+)
+from guppylang_internals.tys.arg import TypeArg
+
+if TYPE_CHECKING:
+    from hugr.build import function as hf
+
+
+def static_array_get(elem_ty: ht.Type) -> ops.ExtOp:
+    """Returns the static array `get` operation."""
+    assert elem_ty.type_bound() == ht.TypeBound.Copyable
+    arr_ty = StaticArray(elem_ty)
+    return EXTENSION.get_op("get").instantiate(
+        [ht.TypeTypeArg(elem_ty)],
+        ht.FunctionType([arr_ty, ht.USize()], [ht.Option(elem_ty)]),
+    )
+
+
+FROZENARRAY_GETITEM: Final[GlobalConstId] = GlobalConstId.fresh(
+    "frozenarray.__getitem__"
+)
+
+
+class FrozenarrayGetitemCompiler(CustomCallCompiler):
+    def getitem_func(self) -> hf.Function:
+        var = ht.Variable(0, ht.TypeBound.Copyable)
+        sig = ht.PolyFuncType(
+            params=[ht.TypeTypeParam(ht.TypeBound.Copyable)],
+            body=ht.FunctionType([StaticArray(var), INT_T], [var]),
+        )
+        func, already_exists = self.ctx.declare_global_func(FROZENARRAY_GETITEM, sig)
+        if not already_exists:
+            [arr, idx] = func.inputs()
+            idx = func.add_op(convert_itousize(), idx)
+            elem_opt = func.add_op(static_array_get(var), arr, idx)
+            elem = build_unwrap(func, elem_opt, "Frozenarray index out of bounds")
+            func.set_outputs(elem)
+        return func
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        [ty_arg, _] = self.type_args
+        assert isinstance(ty_arg, TypeArg)
+        elem_ty = ty_arg.ty.to_hugr(self.ctx)
+        inst = ht.FunctionType([StaticArray(elem_ty), INT_T], [elem_ty])
+        type_args = [ht.TypeTypeArg(elem_ty)]
+        elem = self.builder.call(
+            self.getitem_func(), *args, instantiation=inst, type_args=type_args
+        )
+        return [elem]

guppylang_internals/std/_internal/compiler/futures.py

@@ -0,0 +1,30 @@
+from collections.abc import Callable, Sequence
+
+from hugr import ops
+from hugr import tys as ht
+
+from guppylang_internals.error import InternalGuppyError
+from guppylang_internals.std._internal.compiler.tket_exts import FUTURES_EXTENSION
+from guppylang_internals.tys.arg import Argument, TypeArg
+from guppylang_internals.tys.common import ToHugrContext
+from guppylang_internals.tys.subst import Inst
+
+
+def future_to_hugr(type_args: Sequence[Argument], ctx: ToHugrContext) -> ht.Type:
+    match type_args:
+        case [TypeArg(ty)]:
+            type_def = FUTURES_EXTENSION.get_type("Future")
+            return type_def.instantiate([ht.TypeTypeArg(ty.to_hugr(ctx))])
+        case _:
+            raise InternalGuppyError("Invalid type args for Future type")
+
+
+def future_op(
+    op_name: str,
+) -> Callable[[ht.FunctionType, Inst, ToHugrContext], ops.DataflowOp]:
+    op_def = FUTURES_EXTENSION.get_op(op_name)
+
+    def op(concrete: ht.FunctionType, args: Inst, ctx: ToHugrContext) -> ops.DataflowOp:
+        return op_def.instantiate([arg.to_hugr(ctx) for arg in args], concrete)
+
+    return op

guppylang_internals/std/_internal/compiler/list.py

@@ -0,0 +1,348 @@
+"""Compilers building list functions on top of hugr standard operations, that involve
+multiple nodes.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import hugr.std.collections.list
+from hugr import Wire, ops
+from hugr import tys as ht
+from hugr.std.collections.list import List, ListVal
+
+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_ifromusize,
+    convert_itousize,
+)
+from guppylang_internals.std._internal.compiler.prelude import (
+    build_unwrap,
+    build_unwrap_left,
+    build_unwrap_right,
+)
+from guppylang_internals.tys.arg import TypeArg
+
+if TYPE_CHECKING:
+    from hugr.build.dfg import DfBase
+
+
+# ------------------------------------------------------
+# --------- std.collections operations -----------------
+# ------------------------------------------------------
+
+
+def _instantiate_list_op(
+    name: str, elem_type: ht.Type, inp: list[ht.Type], out: list[ht.Type]
+) -> ops.ExtOp:
+    op_def = hugr.std.collections.list.EXTENSION.get_op(name)
+    return ops.ExtOp(
+        op_def,
+        ht.FunctionType(inp, out),
+        [ht.TypeTypeArg(elem_type)],
+    )
+
+
+def list_pop(elem_type: ht.Type) -> ops.ExtOp:
+    """Returns a list `pop` operation."""
+    list_type = List(elem_type)
+    return _instantiate_list_op(
+        "pop", elem_type, [list_type], [list_type, ht.Option(elem_type)]
+    )
+
+
+def list_push(elem_type: ht.Type) -> ops.ExtOp:
+    """Returns a list `push` operation."""
+    list_type = List(elem_type)
+    return _instantiate_list_op("push", elem_type, [list_type, elem_type], [list_type])
+
+
+def list_get(elem_type: ht.Type) -> ops.ExtOp:
+    """Returns a list `get` operation."""
+    list_type = List(elem_type)
+    return _instantiate_list_op(
+        "get", elem_type, [list_type, ht.USize()], [ht.Option(elem_type)]
+    )
+
+
+def list_set(elem_type: ht.Type) -> ops.ExtOp:
+    """Returns a list `set` operation."""
+    list_type = List(elem_type)
+    return _instantiate_list_op(
+        "set",
+        elem_type,
+        [list_type, ht.USize(), elem_type],
+        [list_type, ht.Either([elem_type], [elem_type])],
+    )
+
+
+def list_insert(elem_type: ht.Type) -> ops.ExtOp:
+    """Returns a list `insert` operation."""
+    list_type = List(elem_type)
+    return _instantiate_list_op(
+        "insert",
+        elem_type,
+        [list_type, ht.USize(), elem_type],
+        [list_type, ht.Either([elem_type], [ht.Unit])],
+    )
+
+
+def list_length(elem_type: ht.Type) -> ops.ExtOp:
+    """Returns a list `length` operation."""
+    list_type = List(elem_type)
+    return _instantiate_list_op(
+        "length", elem_type, [list_type], [list_type, ht.USize()]
+    )
+
+
+# ------------------------------------------------------
+# --------- Custom compilers for non-native ops --------
+# ------------------------------------------------------
+
+
+class ListGetitemCompiler(CustomCallCompiler):
+    """Compiler for the `list.__getitem__` function."""
+
+    def build_classical_getitem(
+        self,
+        list_wire: Wire,
+        idx: Wire,
+        elem_ty: ht.Type,
+    ) -> CallReturnWires:
+        """Lowers a call to `list.__getitem__` for classical lists."""
+        idx = self.builder.add_op(convert_itousize(), idx)
+        result = self.builder.add_op(list_get(elem_ty), list_wire, idx)
+        elem = build_unwrap(self.builder, result, "List index out of bounds")
+        return CallReturnWires(regular_returns=[elem], inout_returns=[list_wire])
+
+    def build_linear_getitem(
+        self,
+        list_wire: Wire,
+        idx: Wire,
+        elem_ty: ht.Type,
+    ) -> CallReturnWires:
+        """Lowers a call to `list.__getitem__` for linear lists."""
+        # Swap out the element at the given index with `None`. The `to_hugr`
+        # implementation of the list type ensures that linear element types are turned
+        # into optionals.
+        elem_opt_ty = ht.Option(elem_ty)
+        none = self.builder.add_op(ops.Tag(0, elem_opt_ty))
+        idx = self.builder.add_op(convert_itousize(), idx)
+        list_wire, result = self.builder.add_op(
+            list_set(elem_opt_ty), list_wire, idx, none
+        )
+        elem_opt = build_unwrap_right(self.builder, result, "List index out of bounds")
+        elem = build_unwrap(
+            self.builder, elem_opt, "Linear list element has already been used"
+        )
+        return CallReturnWires(regular_returns=[elem], inout_returns=[list_wire])
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        [list_wire, idx] = args
+        [elem_ty_arg] = self.type_args
+        assert isinstance(elem_ty_arg, TypeArg)
+        if elem_ty_arg.ty.linear:
+            return self.build_linear_getitem(
+                list_wire, idx, elem_ty_arg.ty.to_hugr(self.ctx)
+            )
+        else:
+            return self.build_classical_getitem(
+                list_wire, idx, elem_ty_arg.ty.to_hugr(self.ctx)
+            )
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        raise InternalGuppyError("Call compile_with_inouts instead")
+
+
+class ListSetitemCompiler(CustomCallCompiler):
+    """Compiler for the `list.__setitem__` function."""
+
+    def build_classical_setitem(
+        self,
+        list_wire: Wire,
+        idx: Wire,
+        elem: Wire,
+        elem_ty: ht.Type,
+    ) -> CallReturnWires:
+        """Lowers a call to `list.__setitem__` for classical lists."""
+        idx = self.builder.add_op(convert_itousize(), idx)
+        list_wire, result = self.builder.add_op(list_set(elem_ty), list_wire, idx, elem)
+        # Unwrap the result, but we don't have to hold onto the returned old value
+        build_unwrap_right(self.builder, result, "List index out of bounds")
+        return CallReturnWires(regular_returns=[], inout_returns=[list_wire])
+
+    def build_linear_setitem(
+        self,
+        list_wire: Wire,
+        idx: Wire,
+        elem: Wire,
+        elem_ty: ht.Type,
+    ) -> CallReturnWires:
+        """Lowers a call to `array.__setitem__` for linear arrays."""
+        # Embed the element into an optional
+        elem_opt_ty = ht.Option(elem_ty)
+        elem = self.builder.add_op(ops.Some(elem_ty), elem)
+        idx = self.builder.add_op(convert_itousize(), idx)
+        list_wire, result = self.builder.add_op(
+            list_set(elem_opt_ty), list_wire, idx, elem
+        )
+        old_elem_opt = build_unwrap_right(
+            self.builder, result, "List index out of bounds"
+        )
+        # Check that the old element was `None`
+        build_unwrap_left(
+            self.builder, old_elem_opt, "Linear list element has not been used"
+        )
+        return CallReturnWires(regular_returns=[], inout_returns=[list_wire])
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        [list_wire, idx, elem] = args
+        [elem_ty_arg] = self.type_args
+        assert isinstance(elem_ty_arg, TypeArg)
+        if elem_ty_arg.ty.linear:
+            return self.build_linear_setitem(
+                list_wire, idx, elem, elem_ty_arg.ty.to_hugr(self.ctx)
+            )
+        else:
+            return self.build_classical_setitem(
+                list_wire, idx, elem, elem_ty_arg.ty.to_hugr(self.ctx)
+            )
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        raise InternalGuppyError("Call compile_with_inouts instead")
+
+
+class ListPopCompiler(CustomCallCompiler):
+    """Compiler for the `list.pop` function."""
+
+    def build_classical_pop(
+        self,
+        list_wire: Wire,
+        elem_ty: ht.Type,
+    ) -> CallReturnWires:
+        """Lowers a call to `list.pop` for classical lists."""
+        list_wire, result = self.builder.add_op(list_pop(elem_ty), list_wire)
+        elem = build_unwrap(self.builder, result, "List index out of bounds")
+        return CallReturnWires(regular_returns=[elem], inout_returns=[list_wire])
+
+    def build_linear_pop(
+        self,
+        list_wire: Wire,
+        elem_ty: ht.Type,
+    ) -> CallReturnWires:
+        """Lowers a call to `list.pop` for linear lists."""
+        elem_opt_ty = ht.Option(elem_ty)
+        list_wire, result = self.builder.add_op(list_pop(elem_opt_ty), list_wire)
+        elem_opt = build_unwrap(self.builder, result, "List index out of bounds")
+        elem = build_unwrap(
+            self.builder, elem_opt, "Linear list element has already been used"
+        )
+        return CallReturnWires(regular_returns=[elem], inout_returns=[list_wire])
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        [list_wire] = args
+        [elem_ty_arg] = self.type_args
+        assert isinstance(elem_ty_arg, TypeArg)
+        if elem_ty_arg.ty.linear:
+            return self.build_linear_pop(list_wire, elem_ty_arg.ty.to_hugr(self.ctx))
+        else:
+            return self.build_classical_pop(list_wire, elem_ty_arg.ty.to_hugr(self.ctx))
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        raise InternalGuppyError("Call compile_with_inouts instead")
+
+
+class ListPushCompiler(CustomCallCompiler):
+    """Compiler for the `list.push` function."""
+
+    def build_classical_push(
+        self,
+        list_wire: Wire,
+        elem: Wire,
+        elem_ty: ht.Type,
+    ) -> CallReturnWires:
+        """Lowers a call to `list.push` for classical lists."""
+        list_wire = self.builder.add_op(list_push(elem_ty), list_wire, elem)
+        return CallReturnWires(regular_returns=[], inout_returns=[list_wire])
+
+    def build_linear_push(
+        self,
+        list_wire: Wire,
+        elem: Wire,
+        elem_ty: ht.Type,
+    ) -> CallReturnWires:
+        """Lowers a call to `list.push` for linear lists."""
+        # Wrap element into an optional
+        elem_opt_ty = ht.Option(elem_ty)
+        elem_opt = self.builder.add_op(ops.Some(elem_ty), elem)
+        list_wire = self.builder.add_op(list_push(elem_opt_ty), list_wire, elem_opt)
+        return CallReturnWires(regular_returns=[], inout_returns=[list_wire])
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        [list_wire, elem] = args
+        [elem_ty_arg] = self.type_args
+        assert isinstance(elem_ty_arg, TypeArg)
+        if elem_ty_arg.ty.linear:
+            return self.build_linear_push(
+                list_wire, elem, elem_ty_arg.ty.to_hugr(self.ctx)
+            )
+        else:
+            return self.build_classical_push(
+                list_wire, elem, elem_ty_arg.ty.to_hugr(self.ctx)
+            )
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        raise InternalGuppyError("Call compile_with_inouts instead")
+
+
+class ListLengthCompiler(CustomCallCompiler):
+    """Compiler for the `list.__len__` function."""
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        [list_wire] = args
+        [elem_ty_arg] = self.type_args
+        assert isinstance(elem_ty_arg, TypeArg)
+        elem_ty = elem_ty_arg.ty.to_hugr(self.ctx)
+        if elem_ty_arg.ty.linear:
+            elem_ty = ht.Option(elem_ty)
+        list_wire, length = self.builder.add_op(list_length(elem_ty), list_wire)
+        length = self.builder.add_op(convert_ifromusize(), length)
+        return CallReturnWires(regular_returns=[length], inout_returns=[list_wire])
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        raise InternalGuppyError("Call compile_with_inouts instead")
+
+
+def list_new(
+    builder: DfBase[ops.DfParentOp], elem_type: ht.Type, args: list[Wire]
+) -> Wire:
+    if elem_type.type_bound() == ht.TypeBound.Linear:
+        return _list_new_linear(builder, elem_type, args)
+    else:
+        return _list_new_classical(builder, elem_type, args)
+
+
+def _list_new_classical(
+    builder: DfBase[ops.DfParentOp], elem_type: ht.Type, args: list[Wire]
+) -> Wire:
+    # This may be simplified in the future with a `new` or `with_capacity` list op
+    # See https://github.com/CQCL/hugr/issues/1508
+    lst = builder.load(ListVal([], elem_ty=elem_type))
+    push_op = list_push(elem_type)
+    for elem in args:
+        lst = builder.add_op(push_op, lst, elem)
+    return lst
+
+
+def _list_new_linear(
+    builder: DfBase[ops.DfParentOp], elem_type: ht.Type, args: list[Wire]
+) -> Wire:
+    elem_opt_ty = ht.Option(elem_type)
+    lst = builder.load(ListVal([], elem_ty=elem_opt_ty))
+    push_op = list_push(elem_opt_ty)
+    for elem in args:
+        elem_opt = builder.add_op(ops.Some(elem_type), elem)
+        lst = builder.add_op(push_op, lst, elem_opt)
+    return lst

guppylang_internals/std/_internal/compiler/mem.py

@@ -0,0 +1,13 @@
+from hugr import Wire, ops
+
+from guppylang_internals.definition.custom import CustomInoutCallCompiler
+from guppylang_internals.definition.value import CallReturnWires
+
+
+class WithOwnedCompiler(CustomInoutCallCompiler):
+    """Compiler for the `with_owned` function."""
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        [val, func] = args
+        [out, val] = self.builder.add_op(ops.CallIndirect(), func, val)
+        return CallReturnWires(regular_returns=[out], inout_returns=[val])

guppylang_internals/std/_internal/compiler/option.py

@@ -0,0 +1,78 @@
+from abc import ABC
+
+from hugr import Wire, ops
+from hugr import tys as ht
+
+from guppylang_internals.definition.custom import (
+    CustomCallCompiler,
+    CustomInoutCallCompiler,
+)
+from guppylang_internals.definition.value import CallReturnWires
+from guppylang_internals.error import InternalGuppyError
+from guppylang_internals.std._internal.compiler.prelude import (
+    build_expect_none,
+    build_unwrap,
+)
+from guppylang_internals.std._internal.compiler.tket_bool import (
+    OPAQUE_FALSE,
+    OPAQUE_TRUE,
+)
+from guppylang_internals.tys.arg import TypeArg
+
+
+class OptionCompiler(CustomInoutCallCompiler, ABC):
+    """Abstract base class for compilers for `Option` methods."""
+
+    @property
+    def option_ty(self) -> ht.Option:
+        match self.type_args:
+            case [TypeArg(ty)]:
+                return ht.Option(ty.to_hugr(self.ctx))
+            case _:
+                raise InternalGuppyError("Invalid type args for Option op")
+
+
+class OptionConstructor(OptionCompiler, CustomCallCompiler):
+    """Compiler for the `Option` constructors `nothing` and `some`."""
+
+    def __init__(self, tag: int):
+        self.tag = tag
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        return [self.builder.add_op(ops.Tag(self.tag, self.option_ty), *args)]
+
+
+class OptionTestCompiler(OptionCompiler):
+    """Compiler for the `Option.is_nothing` and `Option.is_some` methods."""
+
+    def __init__(self, tag: int):
+        self.tag = tag
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        [opt] = args
+        cond = self.builder.add_conditional(opt)
+        for i in [0, 1]:
+            with cond.add_case(i) as case:
+                val = OPAQUE_TRUE if i == self.tag else OPAQUE_FALSE
+                opt = case.add_op(ops.Tag(i, self.option_ty), *case.inputs())
+                case.set_outputs(case.load(val), opt)
+        [res, opt] = cond.outputs()
+        return CallReturnWires(regular_returns=[res], inout_returns=[opt])
+
+
+class OptionUnwrapCompiler(OptionCompiler, CustomCallCompiler):
+    """Compiler for the `Option.unwrap` method."""
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        [opt] = args
+        err = "Option.unwrap: value is `Nothing`"
+        return list(build_unwrap(self.builder, opt, err).outputs())
+
+
+class OptionUnwrapNothingCompiler(OptionCompiler, CustomCallCompiler):
+    """Compiler for the `Option.unwrap_nothing` method."""
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        [opt] = args
+        err = "Option.unwrap: value is `Some`"
+        return list(build_expect_none(self.builder, opt, err).outputs())