Not particularly relevant to this topic, but I think two or three years ago I wrote a class that is kind of halfway between 'variant' and 'any'. Basically you had all the benefits of 'any' except that it didn't dynamically allocate. So you had to specify a maximum size for the object, sort of like:

template<size_t N = 256zu>

class any_variant {

    constexpr std::size_t N = N;

    alignas(max_align_t) byte buf[N];

    type_info const *pti = nullptr;

    void (*destructor)(void*) noexcept = nullptr;

};

The best thing about it was that you got a compiler error (rather than a runtime error) if you tried to host an object that didn't fit, like this:

template<typename Tref>

constexpr any_variant &operator=(Tref &&arg) noexcept(noexcept(remove_cvref_t<Tref>(Tref&&)))

{

    static_assert( N >= sizeof arg );

    if ( destructor )

    {

        destructor(buf);  // better not throw

        destructor = nullptr;

        pti = nullptr;

    }

    typedef remove_cvref_t<Tref> T;

    construct_at<T>( (T*)buf, forward<Tref>(arg) );

    pti = &typeid(T);

    destructor = +[](void *const arg) noexcept

      {

          ((T*)arg)->~T();  // better not throw

      };

}

Might need compiler support to make it 'constexpr' because I cast a void* to a T*.