Trying Out C++26 Executors

The essence of the sender/receiver proposal is essentially this: - first start with a sync function

      result_t foo(params_t);
      ...
      auto result = foo(params);

      void async_foo(params_t params, invokable<result_t> cont) { cont(foo(params)); };
      ...
      invokable<result_t> auot receiver= [](result_t result) {...};
      async_foo(params, receiver);

      auto curried_async_foo(params_t params) { 
        return [params](invokable<result_t> cont) { 
           async_foo(params, cont);
        };}
      ...
      auto op = curried_async_foo(params);
      op(receiver);

      auto foo_sender(param_t params) {
        return [params](invokable<result_t> cont)  {
           return [params, cont]{ 
              async_foo(params, cont);
        };};}
      ...
      auto sender = foo_sender(params);
      auto operation = sender(receiver);
      operation();

The complexity is of course in the details, and I didn't fully appreciate it until I tried to implement a stripped down version of the model (and I'm sure I'm still missing a lot).

The model does work very well with coroutines and can avoid or defer a lot of the expected memory allocations of async operations.

At the end they mention this text:

The authors and NVIDIA do not guarantee that this code is fit for any purpose whatsoever.

And say that it worries them. This is actually a warranty disclaimer (the warranty of fitness for a particular purpose) and has to be written like this to be effective. So I would not read anything into it

Is it just me or are the code examples of the executors absolutely unreadable/comprehensible without reading it 5 times?

Even with different formatters I'd much prefer the tbb variant.

C++ has two ways of naming things: `std::incomprehensible_long_name` and `|`.