Gene's questions

Tenho um Eventdesign bastante direto, que define uma trigger()função e operator co_await()mantém um conjunto de awaitables, que ele retoma quando acionado. Uma demonstração está aqui .

struct Event{
    void trigger();
    auto operator co_await();
private:
    class Awaitable;
    std::set<Awaitable*> awaitables;
    bool triggered;
};

struct Event::Awaitable {
    explicit Awaitable(Event* e) : evt(e) {}
    bool await_ready() const noexcept { return evt->triggered; }
    void await_suspend(std::coroutine_handle<> h) {
        std::cout << "await_suspend\n";
        awaiter = h;
        evt->awaitables.insert(this);
    }
    void await_resume() {std::cout << "await_resume\n"; }
    bool await_must_resume() const noexcept { return false; }
private:
    friend Event;
    Event* evt;
    std::coroutine_handle<> awaiter;
    public:
};

auto Event::operator co_await() { return Awaitable{this}; }

void Event::trigger() {
    triggered = true;
    std::cout << "resuming " << awaitables.size() << " awaitable(s)\n";
    for(auto&& a : std::move(awaitables))
        a->awaiter.resume();
}

Compilar no gcc e executar mostra que await_suspendé chamado, que é o que eu esperaria. Mas o MSVC chama await_resumeem vez disso, o que não consigo explicar. Isso é um bug no compilador ou no UB no design?

Preciso acessar um valor std::tuplepor índice em tempo de execução. Para isso escrevi uma função que retorna a std::variantcom os mesmos tipos inicializados para o índice especificado. A implementação envolve instanciações de modelos recursivos:

template<std::size_t N>
constexpr auto get_n = [](/*tuple-like*/auto&& t, std::size_t index)
{
    using variant_type = decltype(std::apply([](auto&&... v){
        return std::variant<std::monostate, std::remove_cvref_t<decltype(v)>...>{};
    }, t));

    constexpr auto size = std::tuple_size_v<std::remove_cvref_t<decltype(t)>>;

    if constexpr(N > size)
        return variant_type{};
    else 
    {
        if(N == index + 1)
            return variant_type(std::in_place_index<N>, std::get<N - 1>(t));
        else
            return get_n<N + 1>(t, index);
    }
};

constexpr auto tuple_to_variant(/*tuple-like*/auto&& t, std::size_t index)
{
    return get_n<1>(std::forward<decltype(t)>(t), index);
}

Estou usando compiladores c++23. O problema é que apenas o gcc compila sem erros. Os compiladores clang e MSVC entram em loop infinito de instanciação. Isso é um bug nos compiladores? Como posso corrigir esse código que ele compila nos três compiladores?

Aqui está a demonstração do Compiler Explorer

Descobri por acidente, ao modificar o código existente, que uma declaração de alias foi criada std::optional<void>. Veio de um código de modelo como este:

using ret_t = std::invoke_result_t<Fn, Args...>;
using opt_ret_t = std::optional<ret_t>;

Posteriormente, o código discrimina o caso quando o tipo de retorno é (not) void, portanto, nunca há realmente um optionalobjeto criado.

Para ter certeza de que não estava faltando nada, adicionei uma afirmação nesse ramo do código e tudo compila:

static_assert(std::is_same_v<opt_ret_t, std::optional<void>>);

cppreference diz :

Não há referências opcionais, funções, arrays ou cv void; um programa está mal formado se instanciar um opcional com esse tipo.

Portanto, independentemente dos compiladores não reclamarem, esse código está mal formado?