P4013R0: constexpr any of all the things

Raw typeless pointer

std::vector<void *> things;
things.emplace_back(new int{42});
things.emplace_back(new std::string{"who owns me?"});
// you are on your own managing their lifetime, constant evaluation won't let you mess up, but it will be hard

Managing lifetime with unique_ptr

using any_unique_ptr = std::unique_ptr<void, Deleter>;
std::vector<any_unique_ptr> things;
things.emplace_back(any_unique_ptr{new int{42}, +[](int * ptr) { delete ptr; }});
things.emplace_back(any_unique_ptr{new std::string{"I drag this thing around"}, +[](std::string * ptr) { delete ptr; }});
// at least you don't need to manage the lifetime on your own

shared_ptr

std::vector<std::shared_ptr<void>> things;
things.emplace_back(std::static_pointer_cast<void>(std::make_shared_ptr<int>(42)));
things.emplace_back(std::static_pointer_cast<void>(std::make_shared_ptr<std::string>("a helper function will make this nicer")));
// since C++26 this is constexpr

templates and std::polymorphic

You must combine these two together :)

struct custom_any {
	virtual ~base() = default;
};

template <typename T> struct specific_any: custom_any {
	T value;
	constexpr specific_any(Args && ... args): value{std::forward<Args>(args)...} { }
	virtual ~specific_any() = default;
};

template <typename T> specific_any(T) -> specific_any<T>;
// we can't do this, but we can change language to do it:
// template <typename T> custom_any(T) -> specific_any<T>;

using polymorphic_any = std::polymorphic<custom_any>;
std::vector<polymorphic_any> things;
things.emplace_back(polymorphic_any{std::in_place_type<int>, 42});
things.emplace_back(polymorphic_any{std::in_place_type<std::string>, "I wrote my own any yay"});
// you can also write your own `std::any` directly

std::any

std::vector<std::any> things;
things.emplace_back(42);
things.emplace_back("it's almost like javascript :)");
// after this paper, this will work in constexpr too