def sample(self, *exprs: ValueLike) -> 'TickTrigger':
        """Sample expressions when this trigger is activated.

        This method returns a new :class:`TickTrigger` object. When awaited, this object returns,
        in addition to the values that would be otherwise returned by :py:`await trigger`,
        the values of :py:`exprs` (any :class:`~.hdl.ValueLike`) at exactly the moment at which
        the active clock edge, or the asynchronous reset (if applicable), has occurred.

        Combining :meth:`~SimulatorContext.tick` with :meth:`sample` can be used to capture
        the state of a circuit after the active clock edge, but before propagation of signal values
        that have been updated by that clock edge: ::

            async for clk_edge, rst_active, in_a_value, in_b_value in \\
                    ctx.tick().sample(in_a, in_b):
                ...

        Chaining calls to :meth:`sample` has the same effect as calling it once with the combined
        list of arguments. The code below has the same behavior as the code above: ::

            async for clk_edge, rst_active, in_a_value, in_b_value in \\
                    ctx.tick().sample(in_a).sample(in_b):
                ...

        .. note::

            Chaining calls to this method is useful for defining reusable building blocks.
            The following (simplified for clarity) implementation of :meth:`until` takes advantage
            of it by first appending :py:`condition` to the end of the list of captured expressions,
            checking if it holds, and then removing it from the list of sampled values: ::

                async def until(trigger, condition):
                    async for clk_edge, rst_active, *values, done in trigger.sample(condition):
                        if done:
                            return values

        """
        return TickTrigger(self._engine, self._process,
                           domain=self._domain, sampled=(*self._sampled, *exprs))
Sample expressions when this trigger is activated.

        This method returns a new :class:`TickTrigger` object. When awaited, this object returns,
        in addition to the values that would be otherwise returned by :py:`await trigger`,
        the values of :py:`exprs` (any :class:`~.hdl.ValueLike`) at exactly the moment at which
        the active clock edge, or the asynchronous reset (if applicable), has occurred.

        Combining :meth:`~SimulatorContext.tick` with :meth:`sample` can be used to capture
        the state of a circuit after the active clock edge, but before propagation of signal values
        that have been updated by that clock edge: ::

            async for clk_edge, rst_active, in_a_value, in_b_value in \
                    ctx.tick().sample(in_a, in_b):
                ...

        Chaining calls to :meth:`sample` has the same effect as calling it once with the combined
        list of arguments. The code below has the same behavior as the code above: ::

            async for clk_edge, rst_active, in_a_value, in_b_value in \
                    ctx.tick().sample(in_a).sample(in_b):
                ...

        .. note::

            Chaining calls to this method is useful for defining reusable building blocks.
            The following (simplified for clarity) implementation of :meth:`until` takes advantage
            of it by first appending :py:`condition` to the end of the list of captured expressions,
            checking if it holds, and then removing it from the list of sampled values: ::

                async def until(trigger, condition):
                    async for clk_edge, rst_active, *values, done in trigger.sample(condition):
                        if done:
                            return values

        
amaranth/sim/_async.py