when_any question

when_any(job1,job2) completes when either job1 or job2 complete.

I was hopeful that when one of the senders completes, the other would be stopped..

Testing that hypothesis with

#include <chrono>

#include <fmt/core.h>

#include <exec/static_thread_pool.hpp>
#include <exec/when_any.hpp>
#include <stdexec/execution.hpp>

using namespace std::chrono_literals;

int main()
{
        exec::static_thread_pool pool(4);
        stdexec::scheduler auto sch = pool.get_scheduler();

        stdexec::sender auto job1 = stdexec::schedule(sch) | stdexec::then([](){
                int i{0};
                while (true) {
                        fmt::print("job1: {}\n", i++);
                        std::this_thread::sleep_for(200ms);
                }
        });
        stdexec::sender auto job2 = stdexec::schedule(sch) | stdexec::then([](){
                for (int i = 0; i < 5; ++i) {
                        fmt::print("JOB2: {}\n", i);
                        std::this_thread::sleep_for(500ms);
                }
        });
        stdexec::sync_wait(exec::when_any(job1,job2));
}

suggests that this isn't the case.

Bug or feature? Should my job1 be looking for a stop_token in the environment?

I note that P2300 mentions stop_when and doesn't mention when_any. I am guessing that they are synonyms?

Start by reading exec/when_any.hpp and the P2300 discussion of stop_when and cancellation. Run the supplied reproducer to observe whether the losing sender is stopped. Done means the expected cancellation semantics are established and either documented or implemented, with tests covering the behavior.