Method apply_call

python/cudaq/kernel/kernel_builder.py:1389–1430

Apply a call to the given `target` kernel within the function-body of `self` at the provided target arguments. Args: target (:class:`Kernel`): The kernel to call from within `self`. *target_arguments (Optional[:class:`QuakeValue`]): The arguments

(self, target, *target_arguments)

        return

    def apply_call(self, target, *target_arguments):
        """
        Apply a call to the given `target` kernel within the function-body of
        `self` at the provided target arguments.

        Args:
        target (:class:`Kernel`): The kernel to call from within `self`.
        *target_arguments (Optional[:class:`QuakeValue`]):
            The arguments to the `target` kernel. Leave empty if the `target`
            kernel doesn't accept any arguments.

        Raises:
        RuntimeError: if the `*target_arguments` passed to the apply 
            call don't match the argument signature of `target`.

        ```python
            # Example:
            # Build a `Kernel` that's parameterized by a `cudaq.qubit`.
            target_kernel, other_qubit = cudaq.make_kernel(cudaq.qubit)
            target_kernel.x(other_qubit)
            # Build a `Kernel` that will call `target_kernel` within its
            # own function body.
            kernel = cudaq.make_kernel()
            qubit = kernel.qalloc()
            # Use `qubit` as the argument to `target_kernel`.
            kernel.apply_call(target_kernel, qubit)
            # The final measurement of `qubit` should return the 1-state.
            kernel.mz(qubit))
        ```
        """
        if isa_kernel_decorator(target):
            if not target.is_compiled():
                name = target.name
                emitFatalError(
                    f"Kernel '{name}' must be compiled to be used in the kernel builder. "
                    f"Call `{name}.compile()` before initializing the kernel builder, "
                    f"or deactivate deferred compilation:\n\n"
                    f"    @cudaq.kernel(defer_compilation=False)\n"
                    f"    def {name}(...): ...\n")
            target = self.resolve_callable_arg(self.insertPoint,
                                               DecoratorCapture(target))
        self.__applyControlOrAdjoint(target, False, [], *target_arguments)

    def resolve_callable_arg(self, insPt,
                             target: DecoratorCapture | LinkedKernelCapture):