make senders conforming by giving them non-static connect and get_completion_signatures member fns

[ericniebler]

ATTN: this PR drops support for senders with static member functions for connect and get_completion_signatures.

problem

in stdexec today, many of the senders have non-conforming connect and get_completion_signatures member functions. that's because stdexec must support C++20, which does not have C++23's "deducing this" feature.

instead, stdexec::connect has a non-conforming extension where it looks for a static member function connect, like:

template <class Self, class Receiver>
static auto connect(Self&& self, Receiver rcvr) -> opstate_t<Self, Receiver>;

that is a problem because it would prevent senders from stdexec from being used with third party algorithms that are not hip to this subterfuge.

but defining connect with overloads like below comes with its own difficulties:

template <class Receiver>
auto connect(Receiver rcvr) && -> opstate_t<self_t, Receiver>;

template <class Receiver>
auto connect(Receiver rcvr) const & -> opstate_t<self_t const&, Receiver>;

if opstate_t is some metafunction that computes an opstate type, now the compiler must compute the type twice to perform overload resolution. that's more expensive, and can even cause hard failures when things aren't properly constrained.

solution

this pr introduces a portability macro for C++23's deducing this feature. it can be used as follows:

template <class Self, class Receiver>
STDEXEC_EXPLICIT_THIS_BEGIN(auto connect)(this Self&& self, Receiver rcvr)
  -> opstate_t<Self, Receiver>;

STDEXEC_EXPLICIT_THIS_END(connect)

in C++23, this expands simply into:

template <class Self, class Receiver>
auto connect(this Self&& self, Receiver rcvr)
  -> opstate_t<Self, Receiver>;

but in C++20 is expands to:

template <class Self, class Receiver>
static auto static_connect(Self&& self, Receiver rcvr)
  -> opstate_t<Self, Receiver>;

template <class... Ts>
auto connect(Ts&&... ts) &&
  -> decltype(static_connect(std::move(*this), std::forward<Ts>(ts)...)) {
  return static_connect(std::move(*this), std::forward<Ts>(ts)...);
}

template <class... Ts>
auto connect(Ts&&... ts) const &
  -> decltype(static_connect(*this, std::forward<Ts>(ts)...)) {
  return static_connect(*this, std::forward<Ts>(ts)...);
}

now the sender has conforming signatures for connect. behind the scenes, stdexec::connect checks first for a static static_connect member and uses that if it finds one. otherwise, it calls the connect member function.

[copy-pr-bot]

This pull request requires additional validation before any workflows can run on NVIDIA's runners.

Pull request vetters can view their responsibilities here.

Contributors can view more details about this message here.

[ericniebler]

/ok to test 1acd3eb