Before C++26, `std::stop_token` can't model the concept `stoppable_token`

[Cra3z]

Since std::stop_token lacks the nested class template callback_type prior to C++26 and therefore fails to satisfy the stoppable_token concept, should we apply special handling to it?
I suggest adding the class template stoppable_token_traits, through which we can retrieve the stop callback type using stoppable_token_traits::callback_type.
add new file include/beman/detail/stop_token_traits.hpp:

namespace beman::execution::detail {
template<typename Token>
struct stoppable_token_traits;

template<typename Token> requires requires {
    typename check_type_alias_exist<Token::template callback_type>;
}
struct stoppable_token_traits<Token> {
    template<typename Fn>
    using callback_type = typename Token::template callback_type<Fn>;
};

template<>
struct stoppable_token_traits<std::stop_token> {
    template<typename Fn>
    using callback_type = std::stop_callback<Fn>;
};
} // namespace beman::execution::detail

modify include/beman/detail/stop_callback_for_t.hpp:

 #ifndef INCLUDED_BEMAN_EXECUTION_DETAIL_STOP_CALLBACK_FOR
 #define INCLUDED_BEMAN_EXECUTION_DETAIL_STOP_CALLBACK_FOR
 
+#include <beman/execution/detail/stoppable_token_traits.h>
 #include <concepts>
 
 // ----------------------------------------------------------------------------
 
 namespace beman::execution {
 template <class Token, class CallbackFun>
-using stop_callback_for_t = typename Token::template callback_type<CallbackFun>;
+using stop_callback_for_t =
+    typename ::beman::execution::detail::stoppable_token_traits<Token>::template callback_type<CallbackFun>;
 }
 
 namespace beman::execution::detail {

modify include/beman/execution/detail/stoppable_token.hpp:

 #ifndef INCLUDED_BEMAN_EXECUTION_DETAIL_STOPPABLE_TOKEN
 #define INCLUDED_BEMAN_EXECUTION_DETAIL_STOPPABLE_TOKEN
 
-#include <beman/execution/detail/check_type_alias_exist.hpp>
+#include <beman/execution/detail/stoppable_token_traits.h>
 #include <concepts>
 
 // ----------------------------------------------------------------------------
 namespace beman::execution {
 template <typename Token>
 concept stoppable_token = requires(const Token& token) {
-    typename ::beman::execution::detail::check_type_alias_exist<Token::template callback_type>;
+    typename ::beman::execution::detail::check_type_alias_exist<
+        ::beman::execution::detail::stoppable_token_traits<Token>::template callback_type>;
     { token.stop_requested() } noexcept -> ::std::same_as<bool>;
     { token.stop_possible() } noexcept -> ::std::same_as<bool>;
     { Token(token) } noexcept;

[dietmarkuehl]

Interesting: I was unaware that there is actually a std::stop_callback pre-C++26! It did puzzle me how to get the existing std::stop_source updated to support stop callbacks. As it turns out, all there is needed is to add an alias to std::stop_source.

The implication is that, indeed, it makes sense to support std::stop_source lacking this alias. The suggested code changes seem most OK (although I think the header check_type_alias_exist.hpp shouldn't be removed). This change seems like a straight forward improvement.

[dietmarkuehl]

I have created this PR to implement the suggestion. It turns out that it isn't entirely trivial as some versions of libc++ don't implement std::stop_token. The current work-around isn't pretty and the functionality should really be detected by cmake. I'll need to figure out how that should actually be done. I think it would use cmake's check_source_compiles and write a configuration file with suitable defintions which are then used later.