certain non-decomposable senders caus a compilation error

[dietmarkuehl]

The following code results in a compilation error:

#include <beman/execution/execution.hpp>
namespace ex = beman::execution;

namespace {
    struct non_decomposable_sender {
        using sender_concept = ex::sender_t;
        template <typename...>
        static consteval auto get_completion_signatures() { return test_std::completion_signatures<ex::set_value_t()>(); }
        non_decomposable_sender(int, int) {}
    };
}

int main() {
    (void)ex::get_completion_signatures<non_decomposible_sender, ex::env<>>();
}

Removing one of the int constructor parameters causes the code to compile!

The issue is that sender is used with ex::tag_of_t which tries to guess whether a type is decomposable. If it think it can decompose objects of a type it will extract a tag. However, the above type can't be decomposed.

Currently, I don't know how to properly fix the problem. The tentative plan is to rather detect if a sender is built using basic_sender (probably indirectly by actually detecting a nested type) and only try to decompose such senders.

[Cra3z]

@dietmarkuehl The crux of the issue is how to determine the number of elements a type can be decomposed into. I might have a preliminary solution: if the compiler provides something like __builtin_structured_binding_size (e.g., Clang), we can use that. If not, we can use std::tuple_size for tuple-like types, and stick to the current approach for aggregate types. As for non-aggregate types where all data members are public, we are just out of luck.

[dietmarkuehl]

I think thebtag decomposition is only needed for standard library senders. I’m inclined to explicitly detect those.