Hello,

On Fri, Sep 23, 2022 at 8:00 PM Arthur O'Dwyer <arthur.j.odwyer@gmail.com> wrote:
This could be spelled more ergonomically as:
    variant_.dynamic_emplace(deserialized_index, [](auto *p) {
        std::construct_at(p); deserialize(*p, stream);
    });
where you just pass in the index you want to activate, and then the variant calls your visitor with an appropriate `T*` pointer for you to construct into.

In other words:

    std::variant<int, std::string> v;
    v.emplace<1>("hello");  // legal in C++17, but requires a compile-time-constant template argument 1
    v.dynamic_emplace(1, [](auto *p) {
        if constexpr (std::same_as<decltype(p), std::string*>) {
            std::construct_at(p, "hello");
        }
    });  // silly, but legal, in C++Fantasy; permits a run-time-computed function argument 1

Your utility to turn a runtime value into a compile-time integral_constant is certainly more general, but also vastly more expensive (one line of code could blow up into 256 or 65536 instantiations of that generic lambda's operator() template!) and I don't immediately see any really killer app for it. If you need this only for `variant`, then it seems like the generality isn't needed.

my $.02,
Arthur

I still found it useful on tuples as well. The real code is a bit more complicated that the snipshot I gave as an example. There is no `deserialize` function, instead there is a tuple of functors, where the I-th functor of the tuple is used to serialize/deserialize the I-th element of the variant if it holds it.

Hence the real code is more like:
std::find_integral_constant<0, std::variant_size_v<Variant>>(deserialized_index, [&](auto ID)
{
    auto& data = variant_.template emplace<ID>();
    auto& ser = std::get<ID>(serializers_);
    ser.deserialize(data, stream);
});

I don't see how std::find_integral_constant would be more expensive than recursive_union::visit. You still need to instantiate the functor's operator() for each type. Sure one could supply quite a large range to find_integral_constant, but how would that be useful to anyone, unless they already have thousands-large tuples or variants?