#include <execution>

namespace ex = std::execution;

ex::sender auto redeemScheduler(ex::scheduler auto sch) {
  return ex::schedule(sch);
}

#include <execution>
#include <print>
#include <thread>

namespace ex = std::execution;

int main() {
  // Ask for a handle to the "parallel scheduler"; this is
  // expected to be a "system thread pool", which might be
  // the Windows Thread Pool on Windows, Grand Central
  // Dispatch on macOS, or a standard library-provided pool
  // on Linux-based systems
  ex::scheduler auto sch = ex::get_parallel_scheduler();

  // Get the thread ID of the thread in the system thread pool
  // that services our request.
  auto [poolThreadId] =
      // sync_wait starts the sender it's given and waits for
      // the result; the return value is an optional<tuple<…>>
      // so we unwrap it with .value() and destructure the
      // result.
      std::this_thread::sync_wait(
          // Construct a schedule sender from sch that will
          // do nothing, but do so on the system thread pool.
          ex::schedule(sch)
          // Send the result of the schedule sender into a
          // continuation function with then; the empty pack
          // of results produced by the schedule sender becomes
          // the empty argument list passed to the following
          // lambda.
          | ex::then([]() noexcept {
              // Return the ID of the current thread, which
              // will be the ID of a thread in the thread
              // pool.
              return std::this_thread::get_id();
            }))
          .value();

  // For comparison purposes, also capture the ID of the thread
  // running main.
  auto mainThreadId = std::this_thread::get_id();

  std::println("The pool thread had ID {}.", poolThreadId);
  std::println("The main thread has ID {}.", mainThreadId);
}

The pool thread had ID 137816384202304.
The main thread has ID 137816395574208.

#include <functional>

namespace bigcorp {

struct Executor {
  // Invokes work() on this executor's execution resource
  virtual void add(std::function<void()> work) noexcept = 0;
};
  
}

#include <concepts>
#include <execution>
#include <type_traits>
#include <utility>

namespace bigcorp {

class scheduler {
  Executor* exec_;

  // Our schedule operation
  template <class Receiver>
  struct operation {
    // Advertise we're an operation state
    using operation_state_concept = std::execution::operation_state_tag;

    operation(Executor* exec, Receiver rcvr) noexcept
     : exec_(exec), rcvr_(std::move(rcvr)) {}

    void start() & noexcept {
      // When start() is called, we invoke exec_->add to put some
      // work on our executor's queue…
      auto work = [this]() noexcept {
        // …but we don't actually complete our receiver until we
        // get woken up on the appropriate execution context.
        std::execution::set_value(std::move(rcvr_));
      };

      // start() must be noexcept; if this static assertion fails
      // then we ought to handle the exception by catching it and
      // delivering it to the receiver through set_error, but that
      // complicates what is supposed to be demo code
      static_assert(noexcept(exec_->add(std::move(work))));

      exec_->add(std::move(work));
    }

   private:
    Executor* exec_;
    Receiver rcvr_;
  };

  // Our schedule sender
  struct sender {
    // Advertise that we're a sender
    using sender_concept = std::execution::sender_tag;

    // Advertise that we are infallible and only ever complete
    // by invoking set_value with no arguments.
    template <class Sndr, class... Env>
    static consteval auto get_completion_signatures()
      -> std::execution::completion_signatures<
             std::execution::set_value_t()> {
      return {};
    }

    // Implement connect so we can create an operation state
    // given a receiver. It's in connect where we learn what
    // our continuation will be.
    template <class Receiver>
    operation<Receiver> connect(Receiver rcvr) const noexcept {
      return operation<Receiver>(exec_, std::move(rcvr));
    }

   private:
    friend scheduler;

    explicit sender(Executor* exec) noexcept : exec_(exec) {}

    Executor* exec_;
  };

 public:
  using scheduler_concept = std::execution::scheduler_tag;

  explicit scheduler(Executor& exec) noexcept
   : exec_(&exec) {}

  sender schedule() const noexcept {
    return sender{exec_};
  }

  friend bool operator==(scheduler, scheduler) noexcept = default;
};

template <std::derived_from<Executor> Exec>
class execution_context {
  Exec exec_;

 public:
  template <class... T>
    requires std::constructible_from<Exec, T...>
  execution_context(T&&... t)
    noexcept(std::is_nothrow_constructible_v<Exec, T...>)
   : exec_(std::forward<T>(t)...) {}

  scheduler get_scheduler() noexcept {
    return scheduler(exec_);
  }
};

// A simple Executor implementation
struct InlineExecutor : Executor {
  void add(std::function<void()> work) noexcept override {
    work();
  }
};

}

int main() {
  bigcorp::execution_context<bigcorp::InlineExecutor> ctx;

  auto [fortytwo] = std::this_thread::sync_wait(
      std::execution::schedule(ctx.get_scheduler())
      | std::execution::then([]() noexcept { return 42; }));

  return fortytwo;
}