guppylang-internals 0.21.0__py3-none-any.whl

guppylang_internals/std/_internal/compiler/prelude.py

@@ -0,0 +1,271 @@
+"""Compilers building array functions on top of hugr standard operations."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Final, TypeVar
+
+import hugr.std.collections
+import hugr.std.int
+import hugr.std.prelude
+from hugr import Node, Wire, ops
+from hugr import tys as ht
+from hugr import val as hv
+
+from guppylang_internals.compiler.core import CompilerContext, GlobalConstId
+from guppylang_internals.definition.custom import (
+    CustomCallCompiler,
+    CustomInoutCallCompiler,
+)
+from guppylang_internals.definition.value import CallReturnWires
+from guppylang_internals.error import InternalGuppyError
+from guppylang_internals.nodes import ExitKind
+from guppylang_internals.tys.subst import Inst
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from hugr.build import function as hf
+    from hugr.build.dfg import DfBase
+
+    from guppylang_internals.tys.common import ToHugrContext
+    from guppylang_internals.tys.subst import Inst
+
+
+# --------------------------------------------
+# --------------- prelude --------------------
+# --------------------------------------------
+
+
+def error_type() -> ht.ExtType:
+    """Returns the hugr type of an error value."""
+    return hugr.std.PRELUDE.types["error"].instantiate([])
+
+
+@dataclass
+class ErrorVal(hv.ExtensionValue):
+    """Custom value for a floating point number."""
+
+    signal: int
+    message: str
+
+    def to_value(self) -> hv.Extension:
+        name = "ConstError"
+        payload = {"signal": self.signal, "message": self.message}
+        return hv.Extension(name, typ=error_type(), val=payload)
+
+    def __str__(self) -> str:
+        return f"Error({self.signal}): {self.message}"
+
+
+def panic(
+    inputs: list[ht.Type], outputs: list[ht.Type], kind: ExitKind = ExitKind.Panic
+) -> ops.ExtOp:
+    """Returns an operation that panics."""
+    name = "panic" if kind == ExitKind.Panic else "exit"
+    op_def = hugr.std.PRELUDE.get_op(name)
+    args: list[ht.TypeArg] = [
+        ht.ListArg([ht.TypeTypeArg(ty) for ty in inputs]),
+        ht.ListArg([ht.TypeTypeArg(ty) for ty in outputs]),
+    ]
+    sig = ht.FunctionType([error_type(), *inputs], outputs)
+    return ops.ExtOp(op_def, sig, args)
+
+
+# ------------------------------------------------------
+# --------- Custom compilers for non-native ops --------
+# ------------------------------------------------------
+
+
+def build_panic(
+    builder: DfBase[P],
+    in_tys: ht.TypeRow,
+    out_tys: ht.TypeRow,
+    err: Wire,
+    *args: Wire,
+) -> Node:
+    """Builds a panic operation."""
+    op = panic(in_tys, out_tys, ExitKind.Panic)
+    return builder.add_op(op, err, *args)
+
+
+def build_error(builder: DfBase[P], signal: int, msg: str) -> Wire:
+    """Constructs and loads a static error value."""
+    val = ErrorVal(signal, msg)
+    return builder.load(builder.add_const(val))
+
+
+# TODO: Common up build_unwrap_right and build_unwrap_left below once
+#  https://github.com/CQCL/hugr/issues/1596 is fixed
+
+
+def build_unwrap_right(
+    builder: DfBase[P], either: Wire, error_msg: str, error_signal: int = 1
+) -> Node:
+    """Unwraps the right value from a `hugr.tys.Either` value, panicking with the given
+    message if the result is left.
+    """
+    conditional = builder.add_conditional(either)
+    result_ty = builder.hugr.port_type(either.out_port())
+    assert isinstance(result_ty, ht.Sum)
+    [left_tys, right_tys] = result_ty.variant_rows
+    with conditional.add_case(0) as case:
+        error = build_error(case, error_signal, error_msg)
+        case.set_outputs(*build_panic(case, left_tys, right_tys, error, *case.inputs()))
+    with conditional.add_case(1) as case:
+        case.set_outputs(*case.inputs())
+    return conditional.to_node()
+
+
+P = TypeVar("P", bound=ops.DfParentOp)
+
+
+def build_unwrap_left(
+    builder: DfBase[P], either: Wire, error_msg: str, error_signal: int = 1
+) -> Node:
+    """Unwraps the left value from a `hugr.tys.Either` value, panicking with the given
+    message if the result is right.
+    """
+    conditional = builder.add_conditional(either)
+    result_ty = builder.hugr.port_type(either.out_port())
+    assert isinstance(result_ty, ht.Sum)
+    [left_tys, right_tys] = result_ty.variant_rows
+    with conditional.add_case(0) as case:
+        case.set_outputs(*case.inputs())
+    with conditional.add_case(1) as case:
+        error = build_error(case, error_signal, error_msg)
+        case.set_outputs(*build_panic(case, right_tys, left_tys, error, *case.inputs()))
+    return conditional.to_node()
+
+
+def build_unwrap(
+    builder: DfBase[P], option: Wire, error_msg: str, error_signal: int = 1
+) -> Node:
+    """Unwraps an `hugr.tys.Option` value, panicking with the given message if the
+    result is an error.
+    """
+    return build_unwrap_right(builder, option, error_msg, error_signal)
+
+
+def build_expect_none(
+    builder: DfBase[P], option: Wire, error_msg: str, error_signal: int = 1
+) -> Node:
+    """Checks that `hugr.tys.Option` value is `None`, otherwise panics with the given
+    message.
+    """
+    return build_unwrap_left(builder, option, error_msg, error_signal)
+
+
+class MemSwapCompiler(CustomCallCompiler):
+    """Compiler for the `mem_swap` function."""
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        [x, y] = args
+        return CallReturnWires(regular_returns=[], inout_returns=[y, x])
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        raise InternalGuppyError("Call compile_with_inouts instead")
+
+
+UNWRAP_RESULT: Final[GlobalConstId] = GlobalConstId.fresh("unwrap_result")
+
+
+def _build_unwrap_result(func: hf.Function, result_type_var: ht.Variable) -> None:
+    either = func.inputs()[0]
+    conditional = func.add_conditional(either)
+    with conditional.add_case(0) as case:
+        [error] = list(case.inputs())
+        case.set_outputs(
+            *build_panic(case, [error_type()], [result_type_var], error, *case.inputs())
+        )
+    with conditional.add_case(1) as case:
+        case.set_outputs(*case.inputs())
+    func.set_outputs(*conditional.outputs())
+
+
+def unwrap_result(
+    builder: DfBase[P],
+    ctx: CompilerContext,
+    either: Wire,
+) -> Wire:
+    """Builds or retrieves and then calls a function that unwraps an `hugr.tys.Either`
+    value, panicking if the result is an error.
+    """
+    either_ty = builder.hugr.port_type(either.out_port())
+    assert isinstance(either_ty, ht.Either)
+    [error_tys, result_tys] = either_ty.variant_rows
+    # Construct the function signature for unwrapping a result of type T.
+    func_ty = ht.PolyFuncType(
+        params=[ht.TypeTypeParam(ht.TypeBound.Linear)],
+        body=ht.FunctionType(
+            input=[ht.Either(error_tys, [ht.Variable(0, ht.TypeBound.Linear)])],
+            output=[ht.Variable(0, ht.TypeBound.Linear)],
+        ),
+    )
+    # Build global unwrap result function if it doesn't already exist.
+    func, already_exists = ctx.declare_global_func(UNWRAP_RESULT, func_ty)
+    if not already_exists:
+        _build_unwrap_result(func, ht.Variable(0, ht.TypeBound.Linear))
+    # Call the global function.
+    concrete_ty = ht.FunctionType(
+        input=[ht.Either(error_tys, result_tys)], output=result_tys
+    )
+    type_args = [ht.TypeTypeArg(*result_tys)]
+    func_call = builder.call(
+        func.parent_node,
+        either,
+        instantiation=concrete_ty,
+        type_args=type_args,
+    )
+    [result] = list(func_call.outputs())
+    return result
+
+
+class UnwrapOpCompiler(CustomInoutCallCompiler):
+    """Compiler for operations that require unwrapping a result which could potentially
+    cause a panic.
+
+    Args:
+        op: A HUGR operation that outputs an Either<error, result> value.
+    """
+
+    op: Callable[[ht.FunctionType, Inst, ToHugrContext], ops.DataflowOp]
+
+    def __init__(
+        self, op: Callable[[ht.FunctionType, Inst, ToHugrContext], ops.DataflowOp]
+    ):
+        self.op = op
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        assert len(self.ty.output) == 1
+        # To instantiate the op we need a function signature that wraps the output of
+        # the function that is being compiled into an either type.
+        opt_func_type = ht.FunctionType(
+            input=self.ty.input,
+            output=[ht.Either([error_type()], self.ty.output)],
+        )
+        op = self.op(opt_func_type, self.type_args, self.ctx)
+        either = self.builder.add_op(op, *args)
+        result = unwrap_result(self.builder, self.ctx, either)
+        return CallReturnWires(regular_returns=[result], inout_returns=[])
+
+
+class BarrierCompiler(CustomCallCompiler):
+    """Compiler for the `barrier` function."""
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        tys = [t for arg in args if (t := self.builder.hugr.port_type(arg.out_port()))]
+
+        op = hugr.std.prelude.PRELUDE_EXTENSION.get_op("Barrier").instantiate(
+            [ht.ListArg([ht.TypeTypeArg(ty) for ty in tys])]
+        )
+
+        barrier_n = self.builder.add_op(op, *args)
+
+        return CallReturnWires(
+            regular_returns=[], inout_returns=[barrier_n[i] for i in range(len(tys))]
+        )
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        raise InternalGuppyError("Call compile_with_inouts instead")

guppylang_internals/std/_internal/compiler/qsystem.py

@@ -0,0 +1,48 @@
+from hugr import Wire
+from hugr import tys as ht
+from hugr.std.int import int_t
+
+from guppylang_internals.definition.custom import CustomInoutCallCompiler
+from guppylang_internals.definition.value import CallReturnWires
+from guppylang_internals.std._internal.compiler.arithmetic import inarrow_s, iwiden_s
+from guppylang_internals.std._internal.compiler.prelude import build_unwrap_right
+from guppylang_internals.std._internal.compiler.quantum import (
+    RNGCONTEXT_T,
+)
+from guppylang_internals.std._internal.compiler.tket_exts import (
+    QSYSTEM_RANDOM_EXTENSION,
+)
+from guppylang_internals.std._internal.util import external_op
+
+
+class RandomIntCompiler(CustomInoutCallCompiler):
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        [ctx] = args
+        [rnd, ctx] = self.builder.add_op(
+            external_op("RandomInt", [], ext=QSYSTEM_RANDOM_EXTENSION)(
+                ht.FunctionType([RNGCONTEXT_T], [int_t(5), RNGCONTEXT_T]), [], self.ctx
+            ),
+            ctx,
+        )
+        [rnd] = self.builder.add_op(iwiden_s(5, 6), rnd)
+        return CallReturnWires(regular_returns=[rnd], inout_returns=[ctx])
+
+
+class RandomIntBoundedCompiler(CustomInoutCallCompiler):
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        [ctx, bound] = args
+        bound_sum = self.builder.add_op(inarrow_s(6, 5), bound)
+        bound = build_unwrap_right(
+            self.builder, bound_sum, "bound must be a 32-bit integer"
+        )
+        [rnd, ctx] = self.builder.add_op(
+            external_op("RandomIntBounded", [], ext=QSYSTEM_RANDOM_EXTENSION)(
+                ht.FunctionType([RNGCONTEXT_T, int_t(5)], [int_t(5), RNGCONTEXT_T]),
+                [],
+                self.ctx,
+            ),
+            ctx,
+            bound,
+        )
+        [rnd] = self.builder.add_op(iwiden_s(5, 6), rnd)
+        return CallReturnWires(regular_returns=[rnd], inout_returns=[ctx])

guppylang_internals/std/_internal/compiler/quantum.py

@@ -0,0 +1,118 @@
+"""Compilers building list functions on top of hugr standard operations, that involve
+multiple nodes.
+"""
+
+from __future__ import annotations
+
+from hugr import Wire, ops
+from hugr import ext as he
+from hugr import tys as ht
+from hugr.std.float import FLOAT_T
+
+from guppylang_internals.definition.custom import CustomInoutCallCompiler
+from guppylang_internals.definition.value import CallReturnWires
+from guppylang_internals.std._internal.compiler.tket_bool import OpaqueBool, make_opaque
+from guppylang_internals.std._internal.compiler.tket_exts import (
+    QSYSTEM_RANDOM_EXTENSION,
+    QUANTUM_EXTENSION,
+    ROTATION_EXTENSION,
+)
+
+# ----------------------------------------------
+# --------- tket.* extensions -----------------
+# ----------------------------------------------
+
+
+RNGCONTEXT_T_DEF = QSYSTEM_RANDOM_EXTENSION.get_type("context")
+RNGCONTEXT_T = ht.ExtType(RNGCONTEXT_T_DEF)
+
+ROTATION_T_DEF = ROTATION_EXTENSION.get_type("rotation")
+ROTATION_T = ht.ExtType(ROTATION_T_DEF)
+
+
+def from_halfturns_unchecked() -> ops.ExtOp:
+    return ops.ExtOp(
+        ROTATION_EXTENSION.get_op("from_halfturns_unchecked"),
+        ht.FunctionType([FLOAT_T], [ROTATION_T]),
+    )
+
+
+# ------------------------------------------------------
+# --------- Custom compilers for non-native ops --------
+# ------------------------------------------------------
+
+
+class InoutMeasureCompiler(CustomInoutCallCompiler):
+    """Compiler for the measure functions with an inout qubit
+    such as the `project_z` function - requiring conversion to tket.bool."""
+
+    opname: str
+    ext: he.Extension
+
+    def __init__(self, opname: str | None = None, ext: he.Extension | None = None):
+        self.opname = opname or "Measure"
+        self.ext = ext or QUANTUM_EXTENSION
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        from guppylang_internals.std._internal.util import quantum_op
+
+        [q] = args
+        [q, bit] = self.builder.add_op(
+            quantum_op(self.opname, ext=self.ext)(
+                ht.FunctionType([ht.Qubit], [ht.Qubit, ht.Bool]), [], self.ctx
+            ),
+            q,
+        )
+        bit = self.builder.add_op(make_opaque(), bit)
+        return CallReturnWires(regular_returns=[bit], inout_returns=[q])
+
+
+class InoutMeasureResetCompiler(CustomInoutCallCompiler):
+    """Compiler for the measure functions with an inout qubit
+    such as the `project_z` function."""
+
+    opname: str
+    ext: he.Extension
+
+    def __init__(self, opname: str | None = None, ext: he.Extension | None = None):
+        self.opname = opname or "Measure"
+        self.ext = ext or QUANTUM_EXTENSION
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        from guppylang_internals.std._internal.util import quantum_op
+
+        [q] = args
+        [q, bit] = self.builder.add_op(
+            quantum_op(self.opname, ext=self.ext)(
+                ht.FunctionType([ht.Qubit], [ht.Qubit, OpaqueBool]), [], self.ctx
+            ),
+            q,
+        )
+        return CallReturnWires(regular_returns=[bit], inout_returns=[q])
+
+
+class RotationCompiler(CustomInoutCallCompiler):
+    opname: str
+
+    def __init__(self, opname: str):
+        self.opname = opname
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        from guppylang_internals.std._internal.util import quantum_op
+
+        [*qs, angle] = args
+        [halfturns] = self.builder.add_op(ops.UnpackTuple([FLOAT_T]), angle)
+        [rotation] = self.builder.add_op(from_halfturns_unchecked(), halfturns)
+
+        qs = self.builder.add_op(
+            quantum_op(self.opname)(
+                ht.FunctionType(
+                    [ht.Qubit for _ in qs] + [ROTATION_T], [ht.Qubit for _ in qs]
+                ),
+                [],
+                self.ctx,
+            ),
+            *qs,
+            rotation,
+        )
+        return CallReturnWires(regular_returns=[], inout_returns=list(qs))

guppylang_internals/std/_internal/compiler/tket_bool.py

@@ -0,0 +1,55 @@
+from dataclasses import dataclass
+
+from hugr import ops
+from hugr import tys as ht
+from hugr import val as hv
+
+from guppylang_internals.std._internal.compiler.tket_exts import BOOL_EXTENSION
+
+BOOL_DEF = BOOL_EXTENSION.get_type("bool")
+OpaqueBool = ht.ExtType(BOOL_DEF)
+
+
+def read_bool() -> ops.ExtOp:
+    return ops.ExtOp(
+        BOOL_EXTENSION.get_op("read"),
+        ht.FunctionType([OpaqueBool], [ht.Bool]),
+    )
+
+
+def make_opaque() -> ops.ExtOp:
+    return ops.ExtOp(
+        BOOL_EXTENSION.get_op("make_opaque"),
+        ht.FunctionType([ht.Bool], [OpaqueBool]),
+    )
+
+
+def not_op() -> ops.ExtOp:
+    return ops.ExtOp(
+        BOOL_EXTENSION.get_op("not"),
+        ht.FunctionType([OpaqueBool], [OpaqueBool]),
+    )
+
+
+@dataclass
+class OpaqueBoolVal(hv.ExtensionValue):
+    """Custom value for a boolean."""
+
+    v: bool
+
+    def to_value(self) -> hv.Extension:
+        name = "ConstBool"
+        payload = self.v
+        return hv.Extension(
+            name,
+            typ=OpaqueBool,
+            val=payload,
+            extensions=[BOOL_EXTENSION.name],
+        )
+
+    def __str__(self) -> str:
+        return f"{self.v}"
+
+
+OPAQUE_TRUE = OpaqueBoolVal(True)
+OPAQUE_FALSE = OpaqueBoolVal(False)

guppylang_internals/std/_internal/compiler/tket_exts.py

@@ -0,0 +1,59 @@
+from dataclasses import dataclass
+
+from hugr import val
+from tket_exts import (
+    debug,
+    futures,
+    opaque_bool,
+    qsystem,
+    qsystem_random,
+    qsystem_utils,
+    quantum,
+    result,
+    rotation,
+    wasm,
+)
+
+BOOL_EXTENSION = opaque_bool()
+DEBUG_EXTENSION = debug()
+FUTURES_EXTENSION = futures()
+QSYSTEM_EXTENSION = qsystem()
+QSYSTEM_RANDOM_EXTENSION = qsystem_random()
+QSYSTEM_UTILS_EXTENSION = qsystem_utils()
+QUANTUM_EXTENSION = quantum()
+RESULT_EXTENSION = result()
+ROTATION_EXTENSION = rotation()
+WASM_EXTENSION = wasm()
+
+TKET_EXTENSIONS = [
+    BOOL_EXTENSION,
+    DEBUG_EXTENSION,
+    FUTURES_EXTENSION,
+    QSYSTEM_EXTENSION,
+    QSYSTEM_RANDOM_EXTENSION,
+    QSYSTEM_UTILS_EXTENSION,
+    QUANTUM_EXTENSION,
+    RESULT_EXTENSION,
+    ROTATION_EXTENSION,
+    WASM_EXTENSION,
+]
+
+
+@dataclass(frozen=True)
+class ConstWasmModule(val.ExtensionValue):
+    """Python wrapper for the tket ConstWasmModule type"""
+
+    wasm_file: str
+    wasm_hash: int
+
+    def to_value(self) -> val.Extension:
+        ty = WASM_EXTENSION.get_type("module").instantiate([])
+
+        name = "tket.wasm.ConstWasmModule"
+        payload = {"name": self.wasm_file, "hash": self.wasm_hash}
+        return val.Extension(name, typ=ty, val=payload, extensions=["tket.wasm"])
+
+    def __str__(self) -> str:
+        return (
+            f"ConstWasmModule(wasm_file={self.wasm_file}, wasm_hash={self.wasm_hash})"
+        )

guppylang_internals/std/_internal/compiler/wasm.py

@@ -0,0 +1,135 @@
+from hugr import Wire, ops
+from hugr import tys as ht
+
+from guppylang_internals.definition.custom import CustomInoutCallCompiler
+from guppylang_internals.definition.value import CallReturnWires
+from guppylang_internals.error import InternalGuppyError
+from guppylang_internals.nodes import GlobalCall
+from guppylang_internals.std._internal.compiler.arithmetic import convert_itousize
+from guppylang_internals.std._internal.compiler.prelude import build_unwrap
+from guppylang_internals.std._internal.compiler.tket_exts import (
+    FUTURES_EXTENSION,
+    WASM_EXTENSION,
+    ConstWasmModule,
+)
+from guppylang_internals.tys.builtin import (
+    wasm_module_info,
+)
+from guppylang_internals.tys.ty import (
+    FunctionType,
+)
+
+
+class WasmModuleInitCompiler(CustomInoutCallCompiler):
+    """Compiler for initialising WASM modules.
+    Calls tket's "get_context" and unwraps the `Option` result.
+    Returns a `tket.wasm.context` wire.
+    """
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        # Make a ConstWasmModule as a CustomConst
+        assert len(args) == 1
+        ctx_arg = args[0]
+        ctx_wire = self.builder.add_op(convert_itousize(), ctx_arg)
+
+        ctx_ty = WASM_EXTENSION.get_type("context").instantiate([])
+        get_ctx_op = ops.ExtOp(
+            WASM_EXTENSION.get_op("get_context"),
+            ht.FunctionType([ht.USize()], [ht.Option(ctx_ty)]),
+        )
+        node = self.builder.add_op(get_ctx_op, ctx_wire)
+        opt_w: Wire = node[0]
+        err = "Failed to spawn WASM context"
+        out_node = build_unwrap(self.builder, opt_w, err)
+        return CallReturnWires(regular_returns=[out_node], inout_returns=[])
+
+
+class WasmModuleDiscardCompiler(CustomInoutCallCompiler):
+    """Compiler for discarding WASM contexts."""
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        assert len(args) == 1
+        ctx = args[0]
+        op = WASM_EXTENSION.get_op("dispose_context").instantiate([])
+        self.builder.add_op(op, ctx)
+        return CallReturnWires(regular_returns=[], inout_returns=[])
+
+
+class WasmModuleCallCompiler(CustomInoutCallCompiler):
+    """Compiler for WASM calls
+    When a wasm method is called in guppy, we turn it into 2 tket ops:
+    * lookup: wasm.module -> wasm.func
+    * call: wasm.context * wasm.func * inputs -> wasm.context * output
+
+    For the wasm.module that we use in lookup, a constant is created for each
+    call, using the wasm file information embedded in method's `self` argument.
+    """
+
+    fn_name: str
+
+    def __init__(self, name: str) -> None:
+        self.fn_name = name
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        # The arguments should be:
+        # - a WASM context
+        # - any args meant for the WASM function
+        assert len(args) >= 1
+        module_ty = WASM_EXTENSION.get_type("module").instantiate([])
+        ctx_ty = WASM_EXTENSION.get_type("context").instantiate([])
+
+        fn_name_arg = ht.StringArg(self.fn_name)
+        # Function type without Inout context arg (for building)
+        assert isinstance(self.node, GlobalCall)
+        assert self.func is not None
+        wasm_sig = FunctionType(
+            self.func.ty.inputs[1:],
+            self.func.ty.output,
+        ).to_hugr(self.ctx)
+
+        inputs_row_arg = ht.ListArg([ty.type_arg() for ty in wasm_sig.input])
+        output_row_arg = ht.ListArg([ty.type_arg() for ty in wasm_sig.output])
+
+        func_ty = WASM_EXTENSION.get_type("func").instantiate(
+            [inputs_row_arg, output_row_arg]
+        )
+        future_ty = FUTURES_EXTENSION.get_type("Future").instantiate(
+            [ht.Tuple(*wasm_sig.output).type_arg()]
+        )
+
+        # Get the WASM module information from the type
+        selfarg = self.func.ty.inputs[0].ty
+        if info := wasm_module_info(selfarg):
+            const_module = self.builder.add_const(ConstWasmModule(*info))
+        else:
+            raise InternalGuppyError(
+                "Expected cached signature to have WASM module as first arg"
+            )
+
+        wasm_module = self.builder.load(const_module)
+
+        # Lookup the function we want
+        wasm_opdef = WASM_EXTENSION.get_op("lookup").instantiate(
+            [fn_name_arg, inputs_row_arg, output_row_arg],
+            ht.FunctionType([module_ty], [func_ty]),
+        )
+        wasm_func = self.builder.add_op(wasm_opdef, wasm_module)
+
+        # Call the function
+        call_op = WASM_EXTENSION.get_op("call").instantiate(
+            [inputs_row_arg, output_row_arg],
+            ht.FunctionType([ctx_ty, func_ty, *wasm_sig.input], [ctx_ty, future_ty]),
+        )
+
+        ctx, future = self.builder.add_op(call_op, args[0], wasm_func, *args[1:])
+
+        read_opdef = FUTURES_EXTENSION.get_op("Read").instantiate(
+            [ht.Tuple(*wasm_sig.output).type_arg()],
+            ht.FunctionType([future_ty], [ht.Tuple(*wasm_sig.output)]),
+        )
+        result = self.builder.add_op(read_opdef, future)
+        ws: list[Wire] = list(result[:])
+        node = self.builder.add_op(ops.UnpackTuple(wasm_sig.output), *ws)
+        ws: list[Wire] = list(node[:])
+
+        return CallReturnWires(regular_returns=ws, inout_returns=[ctx])