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

guppylang_internals/decorator.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import inspect
-from typing import TYPE_CHECKING, ParamSpec, TypeVar
+from typing import TYPE_CHECKING, ParamSpec, TypeVar, overload
 
 from hugr import ops
 from hugr import tys as ht
@@ -42,6 +42,7 @@ from guppylang_internals.tys.ty import (
 )
 
 if TYPE_CHECKING:
+    import ast
     import builtins
     from collections.abc import Callable, Sequence
     from types import FrameType
@@ -121,15 +122,19 @@ def hugr_op(
     return custom_function(OpCompiler(op), checker, higher_order_value, name, signature)
 
 
-def extend_type(defn: TypeDef) -> Callable[[type], type]:
-    """Decorator to add new instance functions to a type."""
+def extend_type(defn: TypeDef, return_class: bool = False) -> Callable[[type], type]:
+    """Decorator to add new instance functions to a type.
+
+    By default, returns a `GuppyDefinition` object referring to the type. Alternatively,
+    `return_class=True` can be set to return the decorated class unchanged.
+    """
     from guppylang.defs import GuppyDefinition
 
     def dec(c: type) -> type:
         for val in c.__dict__.values():
             if isinstance(val, GuppyDefinition):
                 DEF_STORE.register_impl(defn.id, val.wrapped.name, val.id)
-        return c
+        return c if return_class else GuppyDefinition(defn)  # type: ignore[return-value]
 
     return dec
 
@@ -181,63 +186,124 @@ def custom_type(
 
 
 def wasm_module(
-    filename: str, filehash: int
+    filename: str,
 ) -> Callable[[builtins.type[T]], GuppyDefinition]:
-    from guppylang.defs import GuppyDefinition
-
-    def dec(cls: builtins.type[T]) -> GuppyDefinition:
-        # N.B. Only one module per file and vice-versa
-        wasm_module = WasmModuleTypeDef(
-            DefId.fresh(),
-            cls.__name__,
-            None,
-            filename,
-            filehash,
-        )
-
-        wasm_module_ty = wasm_module.check_instantiate([], None)
-
-        DEF_STORE.register_def(wasm_module, get_calling_frame())
-        for val in cls.__dict__.values():
-            if isinstance(val, GuppyDefinition):
-                DEF_STORE.register_impl(wasm_module.id, val.wrapped.name, val.id)
-        # Add a constructor to the class
-        call_method = CustomFunctionDef(
-            DefId.fresh(),
-            "__new__",
-            None,
-            FunctionType(
-                [FuncInput(NumericType(NumericType.Kind.Nat), flags=InputFlags.Owned)],
-                wasm_module_ty,
-            ),
-            DefaultCallChecker(),
-            WasmModuleInitCompiler(),
-            True,
-            GlobalConstId.fresh(f"{cls.__name__}.__new__"),
-            True,
-        )
-        discard = CustomFunctionDef(
-            DefId.fresh(),
-            "discard",
-            None,
-            FunctionType([FuncInput(wasm_module_ty, InputFlags.Owned)], NoneType()),
-            DefaultCallChecker(),
-            WasmModuleDiscardCompiler(),
-            False,
-            GlobalConstId.fresh(f"{cls.__name__}.__discard__"),
-            True,
-        )
-        DEF_STORE.register_def(call_method, get_calling_frame())
-        DEF_STORE.register_impl(wasm_module.id, "__new__", call_method.id)
-        DEF_STORE.register_def(discard, get_calling_frame())
-        DEF_STORE.register_impl(wasm_module.id, "discard", discard.id)
+    def type_def_wrapper(
+        id: DefId,
+        name: str,
+        defined_at: ast.AST | None,
+        wasm_file: str,
+        config: str | None,
+    ) -> OpaqueTypeDef:
+        assert config is None
+        return WasmModuleTypeDef(id, name, defined_at, wasm_file)
+
+    f = ext_module_decorator(
+        type_def_wrapper, WasmModuleInitCompiler(), WasmModuleDiscardCompiler(), True
+    )
+    return f(filename, None)
 
-        return GuppyDefinition(wasm_module)
-
-    return dec
 
+def ext_module_decorator(
+    type_def: Callable[[DefId, str, ast.AST | None, str, str | None], OpaqueTypeDef],
+    init_compiler: CustomInoutCallCompiler,
+    discard_compiler: CustomInoutCallCompiler,
+    init_arg: bool,  # Whether the init function should take a nat argument
+) -> Callable[[str, str | None], Callable[[builtins.type[T]], GuppyDefinition]]:
+    from guppylang.defs import GuppyDefinition
 
-def wasm(f: Callable[P, T]) -> GuppyFunctionDefinition[P, T]:
+    def fun(
+        filename: str, module: str | None
+    ) -> Callable[[builtins.type[T]], GuppyDefinition]:
+        def dec(cls: builtins.type[T]) -> GuppyDefinition:
+            # N.B. Only one module per file and vice-versa
+            ext_module = type_def(
+                DefId.fresh(),
+                cls.__name__,
+                None,
+                filename,
+                module,
+            )
+
+            ext_module_ty = ext_module.check_instantiate([], None)
+
+            DEF_STORE.register_def(ext_module, get_calling_frame())
+            for val in cls.__dict__.values():
+                if isinstance(val, GuppyDefinition):
+                    DEF_STORE.register_impl(ext_module.id, val.wrapped.name, val.id)
+            # Add a constructor to the class
+            if init_arg:
+                init_fn_ty = FunctionType(
+                    [
+                        FuncInput(
+                            NumericType(NumericType.Kind.Nat),
+                            flags=InputFlags.Owned,
+                        )
+                    ],
+                    ext_module_ty,
+                )
+            else:
+                init_fn_ty = FunctionType([], ext_module_ty)
+
+            call_method = CustomFunctionDef(
+                DefId.fresh(),
+                "__new__",
+                None,
+                init_fn_ty,
+                DefaultCallChecker(),
+                init_compiler,
+                True,
+                GlobalConstId.fresh(f"{cls.__name__}.__new__"),
+                True,
+            )
+            discard = CustomFunctionDef(
+                DefId.fresh(),
+                "discard",
+                None,
+                FunctionType([FuncInput(ext_module_ty, InputFlags.Owned)], NoneType()),
+                DefaultCallChecker(),
+                discard_compiler,
+                False,
+                GlobalConstId.fresh(f"{cls.__name__}.__discard__"),
+                True,
+            )
+            DEF_STORE.register_def(call_method, get_calling_frame())
+            DEF_STORE.register_impl(ext_module.id, "__new__", call_method.id)
+            DEF_STORE.register_def(discard, get_calling_frame())
+            DEF_STORE.register_impl(ext_module.id, "discard", discard.id)
+
+            return GuppyDefinition(ext_module)
+
+        return dec
+
+    return fun
+
+
+@overload
+def wasm(arg: Callable[P, T]) -> GuppyFunctionDefinition[P, T]: ...
+
+
+@overload
+def wasm(arg: int) -> Callable[[Callable[P, T]], GuppyFunctionDefinition[P, T]]: ...
+
+
+def wasm(
+    arg: int | Callable[P, T],
+) -> (
+    GuppyFunctionDefinition[P, T]
+    | Callable[[Callable[P, T]], GuppyFunctionDefinition[P, T]]
+):
+    if isinstance(arg, int):
+
+        def wrapper(f: Callable[P, T]) -> GuppyFunctionDefinition[P, T]:
+            return wasm_helper(arg, f)
+
+        return wrapper
+    else:
+        return wasm_helper(None, arg)
+
+
+def wasm_helper(fn_id: int | None, f: Callable[P, T]) -> GuppyFunctionDefinition[P, T]:
     from guppylang.defs import GuppyFunctionDefinition
 
     func = RawWasmFunctionDef(
@@ -246,7 +312,7 @@ def wasm(f: Callable[P, T]) -> GuppyFunctionDefinition[P, T]:
         None,
         f,
         WasmCallChecker(),
-        WasmModuleCallCompiler(f.__name__),
+        WasmModuleCallCompiler(f.__name__, fn_id),
         True,
         signature=None,
     )

guppylang_internals/definition/const.py

@@ -15,7 +15,7 @@ from guppylang_internals.definition.value import (
     ValueDef,
 )
 from guppylang_internals.span import SourceMap
-from guppylang_internals.tys.parsing import type_from_ast
+from guppylang_internals.tys.parsing import TypeParsingCtx, type_from_ast
 
 
 @dataclass(frozen=True)
@@ -33,7 +33,7 @@ class RawConstDef(ParsableDef):
             self.id,
             self.name,
             self.defined_at,
-            type_from_ast(self.type_ast, globals, {}),
+            type_from_ast(self.type_ast, TypeParsingCtx(globals)),
             self.type_ast,
             self.value,
         )

guppylang_internals/definition/custom.py

@@ -169,7 +169,7 @@ class RawCustomFunctionDef(ParsableDef):
             raise GuppyError(NoSignatureError(node, self.name))
 
         if requires_type_annotation:
-            return check_signature(node, globals)
+            return check_signature(node, globals, self.id)
         else:
             return None
 

guppylang_internals/definition/declaration.py

@@ -68,7 +68,7 @@ class RawFunctionDecl(ParsableDef):
     def parse(self, globals: Globals, sources: SourceMap) -> "CheckedFunctionDecl":
         """Parses and checks the user-provided signature of the function."""
         func_ast, docstring = parse_py_func(self.python_func, sources)
-        ty = check_signature(func_ast, globals)
+        ty = check_signature(func_ast, globals, self.id)
         if not has_empty_body(func_ast):
             raise GuppyError(BodyNotEmptyError(func_ast.body[0], self.name))
         # Make sure we won't need monomorphization to compile this declaration

guppylang_internals/definition/extern.py

@@ -14,7 +14,7 @@ from guppylang_internals.definition.value import (
     ValueDef,
 )
 from guppylang_internals.span import SourceMap
-from guppylang_internals.tys.parsing import type_from_ast
+from guppylang_internals.tys.parsing import TypeParsingCtx, type_from_ast
 
 
 @dataclass(frozen=True)
@@ -33,7 +33,7 @@ class RawExternDef(ParsableDef):
             self.id,
             self.name,
             self.defined_at,
-            type_from_ast(self.type_ast, globals, {}),
+            type_from_ast(self.type_ast, TypeParsingCtx(globals)),
             self.symbol,
             self.constant,
             self.type_ast,

guppylang_internals/definition/function.py

@@ -73,7 +73,7 @@ class RawFunctionDef(ParsableDef):
     def parse(self, globals: Globals, sources: SourceMap) -> "ParsedFunctionDef":
         """Parses and checks the user-provided signature of the function."""
         func_ast, docstring = parse_py_func(self.python_func, sources)
-        ty = check_signature(func_ast, globals)
+        ty = check_signature(func_ast, globals, self.id)
         return ParsedFunctionDef(self.id, self.name, func_ast, ty, docstring)
 
 

guppylang_internals/definition/parameter.py

@@ -56,9 +56,9 @@ class RawConstVarDef(ParamDef, ParsableDef):
     description: str = field(default="const variable", init=False)
 
     def parse(self, globals: Globals, sources: SourceMap) -> "ConstVarDef":
-        from guppylang_internals.tys.parsing import type_from_ast
+        from guppylang_internals.tys.parsing import TypeParsingCtx, type_from_ast
 
-        ty = type_from_ast(self.type_ast, globals, {})
+        ty = type_from_ast(self.type_ast, TypeParsingCtx(globals))
         if not ty.copyable or not ty.droppable:
             raise GuppyError(LinearConstVarError(self.type_ast, self.name, ty))
         return ConstVarDef(self.id, self.name, self.defined_at, ty)

guppylang_internals/definition/pytket_circuits.py

@@ -85,7 +85,7 @@ class RawPytketDef(ParsableDef):
         if not has_empty_body(func_ast):
             # Function stub should have empty body.
             raise GuppyError(BodyNotEmptyError(func_ast.body[0], self.name))
-        stub_signature = check_signature(func_ast, globals)
+        stub_signature = check_signature(func_ast, globals, self.id)
 
         # Compare signatures.
         circuit_signature = _signature_from_circuit(self.input_circuit, self.defined_at)

guppylang_internals/definition/struct.py

@@ -3,7 +3,7 @@ import inspect
 import linecache
 import sys
 from collections.abc import Sequence
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from types import FrameType
 from typing import ClassVar
 
@@ -39,7 +39,7 @@ from guppylang_internals.ipython_inspect import is_running_ipython
 from guppylang_internals.span import SourceMap, Span, to_span
 from guppylang_internals.tys.arg import Argument
 from guppylang_internals.tys.param import Parameter, check_all_args
-from guppylang_internals.tys.parsing import type_from_ast
+from guppylang_internals.tys.parsing import TypeParsingCtx, type_from_ast
 from guppylang_internals.tys.ty import (
     FuncInput,
     FunctionType,
@@ -115,6 +115,7 @@ class RawStructDef(TypeDef, ParsableDef):
     """A raw struct type definition that has not been parsed yet."""
 
     python_class: type
+    params: None = field(default=None, init=False)  # Params not known yet
 
     def parse(self, globals: Globals, sources: SourceMap) -> "ParsedStructDef":
         """Parses the raw class object into an AST and checks that it is well-formed."""
@@ -211,15 +212,16 @@ class ParsedStructDef(TypeDef, CheckableDef):
 
     def check(self, globals: Globals) -> "CheckedStructDef":
         """Checks that all struct fields have valid types."""
+        param_var_mapping = {p.name: p for p in self.params}
+        ctx = TypeParsingCtx(globals, param_var_mapping)
+
         # Before checking the fields, make sure that this definition is not recursive,
         # otherwise the code below would not terminate.
         # TODO: This is not ideal (see todo in `check_instantiate`)
-        param_var_mapping = {p.name: p for p in self.params}
-        check_not_recursive(self, globals, param_var_mapping)
+        check_not_recursive(self, ctx)
 
         fields = [
-            StructField(f.name, type_from_ast(f.type_ast, globals, param_var_mapping))
-            for f in self.fields
+            StructField(f.name, type_from_ast(f.type_ast, ctx)) for f in self.fields
         ]
         return CheckedStructDef(
             self.id, self.name, self.defined_at, self.params, fields
@@ -370,9 +372,7 @@ def params_from_ast(nodes: Sequence[ast.expr], globals: Globals) -> list[Paramet
     return params
 
 
-def check_not_recursive(
-    defn: ParsedStructDef, globals: Globals, param_var_mapping: dict[str, Parameter]
-) -> None:
+def check_not_recursive(defn: ParsedStructDef, ctx: TypeParsingCtx) -> None:
     """Throws a user error if the given struct definition is recursive."""
 
     # TODO: The implementation below hijacks the type parsing logic to detect recursive
@@ -388,5 +388,5 @@ def check_not_recursive(
     original = defn.check_instantiate
     object.__setattr__(defn, "check_instantiate", dummy_check_instantiate)
     for fld in defn.fields:
-        type_from_ast(fld.type_ast, globals, param_var_mapping)
+        type_from_ast(fld.type_ast, ctx)
     object.__setattr__(defn, "check_instantiate", original)

guppylang_internals/definition/traced.py

@@ -48,7 +48,7 @@ class RawTracedFunctionDef(ParsableDef):
     def parse(self, globals: Globals, sources: SourceMap) -> "TracedFunctionDef":
         """Parses and checks the user-provided signature of the function."""
         func_ast, _docstring = parse_py_func(self.python_func, sources)
-        ty = check_signature(func_ast, globals)
+        ty = check_signature(func_ast, globals, self.id)
         if ty.parametrized:
             raise GuppyError(UnsupportedError(func_ast, "Generic comptime functions"))
         return TracedFunctionDef(self.id, self.name, func_ast, ty, self.python_func)

guppylang_internals/definition/ty.py

@@ -18,6 +18,12 @@ class TypeDef(Definition):
 
     description: str = field(default="type", init=False)
 
+    #: Generic parameters of the type. This may be `None` for special types that are
+    #: more polymorphic than the regular type system allows (for example `tuple` and
+    #: `Callable`), or if this is a raw definition whose parameters are not determined
+    #: yet (for example a `RawStructDef`).
+    params: Sequence[Parameter] | None
+
     @abstractmethod
     def check_instantiate(
         self, args: Sequence[Argument], loc: AstNode | None = None

guppylang_internals/definition/wasm.py

@@ -11,7 +11,7 @@ from guppylang_internals.definition.custom import (
 )
 from guppylang_internals.error import GuppyError
 from guppylang_internals.span import SourceMap
-from guppylang_internals.tys.builtin import wasm_module_info
+from guppylang_internals.tys.builtin import wasm_module_name
 from guppylang_internals.tys.ty import (
     FuncInput,
     FunctionType,
@@ -30,7 +30,7 @@ class RawWasmFunctionDef(RawCustomFunctionDef):
     def sanitise_type(self, loc: AstNode | None, fun_ty: FunctionType) -> None:
         # Place to highlight in error messages
         match fun_ty.inputs[0]:
-            case FuncInput(ty=ty, flags=InputFlags.Inout) if wasm_module_info(
+            case FuncInput(ty=ty, flags=InputFlags.Inout) if wasm_module_name(
                 ty
             ) is not None:
                 pass

guppylang_internals/engine.py

@@ -41,6 +41,7 @@ from guppylang_internals.tys.builtin import (
     nat_type_def,
     none_type_def,
     option_type_def,
+    self_type_def,
     sized_iter_type_def,
     string_type_def,
     tuple_type_def,
@@ -51,6 +52,7 @@ if TYPE_CHECKING:
 
 BUILTIN_DEFS_LIST: list[RawDef] = [
     callable_type_def,
+    self_type_def,
     tuple_type_def,
     none_type_def,
     bool_type_def,
@@ -84,12 +86,14 @@ class DefinitionStore:
 
     raw_defs: dict[DefId, RawDef]
     impls: defaultdict[DefId, dict[str, DefId]]
+    impl_parents: dict[DefId, DefId]
     frames: dict[DefId, FrameType]
     sources: SourceMap
 
     def __init__(self) -> None:
         self.raw_defs = {defn.id: defn for defn in BUILTIN_DEFS_LIST}
         self.impls = defaultdict(dict)
+        self.impl_parents = {}
         self.frames = {}
         self.sources = SourceMap()
 
@@ -99,7 +103,9 @@ class DefinitionStore:
             self.frames[defn.id] = frame
 
     def register_impl(self, ty_id: DefId, name: str, impl_id: DefId) -> None:
+        assert impl_id not in self.impl_parents, "Already an impl"
         self.impls[ty_id][name] = impl_id
+        self.impl_parents[impl_id] = ty_id
         # Update the frame of the definition to the frame of the defining class
         if impl_id in self.frames:
             frame = self.frames[impl_id].f_back
@@ -138,18 +144,23 @@ class CompilationEngine:
     types_to_check_worklist: dict[DefId, ParsedDef]
     to_check_worklist: dict[DefId, ParsedDef]
 
+    def __init__(self) -> None:
+        """Resets the compilation cache."""
+        self.reset()
+        self.additional_extensions = []
+
     def reset(self) -> None:
         """Resets the compilation cache."""
         self.parsed = {}
         self.checked = {}
         self.compiled = {}
-        self.additional_extensions = []
         self.to_check_worklist = {}
         self.types_to_check_worklist = {}
 
     @pretty_errors
     def register_extension(self, extension: Extension) -> None:
-        self.additional_extensions.append(extension)
+        if extension not in self.additional_extensions:
+            self.additional_extensions.append(extension)
 
     @pretty_errors
     def get_parsed(self, id: DefId) -> ParsedDef:

guppylang_internals/nodes.py

@@ -166,17 +166,6 @@ class MakeIter(ast.expr):
         self.unwrap_size_hint = unwrap_size_hint
 
 
-class IterHasNext(ast.expr):
-    """Checks if an iterator has a next element using the `__hasnext__` magic method.
-
-    This node is inserted in `for` loops and list comprehensions.
-    """
-
-    value: ast.expr
-
-    _fields = ("value",)
-
-
 class IterNext(ast.expr):
     """Obtains the next element of an iterator using the `__next__` magic method.
 
@@ -188,18 +177,6 @@ class IterNext(ast.expr):
     _fields = ("value",)
 
 
-class IterEnd(ast.expr):
-    """Finalises an iterator using the `__end__` magic method.
-
-    This node is inserted in `for` loops and list comprehensions. It is needed to
-    consume linear iterators once they are finished.
-    """
-
-    value: ast.expr
-
-    _fields = ("value",)
-
-
 class DesugaredGenerator(ast.expr):
     """A single desugared generator in a list comprehension.
 

guppylang_internals/std/_internal/compiler/tket_exts.py

@@ -47,16 +47,13 @@ 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}
+        name = "ConstWasmModule"
+        payload = {"module_filename": self.wasm_file}
         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})"
-        )
+        return f"tket.wasm.module(module_filename={self.wasm_file})"

guppylang_internals/std/_internal/compiler/wasm.py

@@ -8,12 +8,11 @@ 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,
+    wasm_module_name,
 )
 from guppylang_internals.tys.ty import (
     FunctionType,
@@ -57,18 +56,20 @@ class WasmModuleDiscardCompiler(CustomInoutCallCompiler):
 
 class WasmModuleCallCompiler(CustomInoutCallCompiler):
     """Compiler for WASM calls
-    When a wasm method is called in guppy, we turn it into 2 tket ops:
+    When a wasm method is called in guppy, we turn it into 3 tket ops:
     * lookup: wasm.module -> wasm.func
-    * call: wasm.context * wasm.func * inputs -> wasm.context * output
-
+    * call: wasm.context * wasm.func * inputs -> wasm.result
+    * read_result: wasm.result -> wasm.context * outputs
     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
+    fn_id: int | None
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str, id_: int | None) -> None:
         self.fn_name = name
+        self.fn_id = id_
 
     def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
         # The arguments should be:
@@ -93,14 +94,13 @@ class WasmModuleCallCompiler(CustomInoutCallCompiler):
         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()]
-        )
+        result_ty = WASM_EXTENSION.get_type("result").instantiate([output_row_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))
+        info = wasm_module_name(selfarg)
+        if info is not None:
+            const_module = self.builder.add_const(ConstWasmModule(info))
         else:
             raise InternalGuppyError(
                 "Expected cached signature to have WASM module as first arg"
@@ -109,27 +109,38 @@ class WasmModuleCallCompiler(CustomInoutCallCompiler):
         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]),
-        )
+        if self.fn_id is None:
+            fn_name_arg = ht.StringArg(self.fn_name)
+            wasm_opdef = WASM_EXTENSION.get_op("lookup_by_name").instantiate(
+                [fn_name_arg, inputs_row_arg, output_row_arg],
+                ht.FunctionType([module_ty], [func_ty]),
+            )
+        else:
+            fn_id_arg = ht.BoundedNatArg(self.fn_id)
+            wasm_opdef = WASM_EXTENSION.get_op("lookup_by_id").instantiate(
+                [fn_id_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]),
+            ht.FunctionType([ctx_ty, func_ty, *wasm_sig.input], [result_ty]),
         )
 
-        ctx, future = self.builder.add_op(call_op, args[0], wasm_func, *args[1:])
+        result = 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)]),
+        read_opdef = WASM_EXTENSION.get_op("read_result").instantiate(
+            [output_row_arg],
+            ht.FunctionType([result_ty], [ctx_ty, *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])
+        data = self.builder.add_op(read_opdef, result)
+        match list(data[:]):
+            case [ctx]:
+                return CallReturnWires(regular_returns=[], inout_returns=[ctx])
+            case [ctx, *values]:
+                return CallReturnWires(regular_returns=[*values], inout_returns=[ctx])
+            case _:
+                raise AssertionError("impossible")