Extract the core engine (and make a paper out of it?)

[brenoguim]

The fundamental building blocks of this library can be seen as:

template<class... Ts>
auto allocate_adjacent_arrays(std::integral auto... sizes) -> std::tuple<std::pair<Ts*, Ts*>...>;

This function would allocate a single block of memory that fits sizeof...(Ts) arrays which the sizes are given in sizes. The return value returns pointers to (non-constructed) objects inside this.

The second building block would be something like std::uninitialized_value_construct which support multiple begin/end iterators.

Then it should be very easy to build this library.

[brenoguim]

If we extract the more fundamental building block that creates the layout of the structure, and make that constexpr, it would be possible to implement a std::tuple without inheritance, and even avoid using space for empty components in the tuple. Not sure if that is undefined behavior though.

[brenoguim]

This would be a much better low level engine: https://godbolt.org/z/xfzq97nKK

auto foo()
{
    int from[] = {1, 2, 3, 4, 5, 6};
    auto r = mynew(with<int, Copy>(5, from),
                   with<float, Fill>(10, 1.0f),
                   with<long, Default>(12),
                   with<char, Value>(5)
                   );
    mydestroy(r);
    return r;
}

This allocates the memory buffer for multiple arrays, initialize them with various configurations (inspired from uninitialized_default_construct, uninitialized_value_construct, uninitialized_copy and uninitialized_fill) and returns a tuple of handles to this array.

The whole structure can be destroyed (in reverse order) by passing in the same tuple of elements.

In the shared_ptr example, library writers could use this low level function to do:

auto arrays = mynew(with<ControlBlock, Default>(1), with<T, Default>(n));
_controlBlock = std::get<0>(arrays).begin();
_controlBlock->size = n;
_ts = std::get<1>(arrays);

however in the destructor, the structure has to be rebuilt:

std::tuple<rng<ControlBlock*>, rng<T*>> arrays { {_controlBlock, _controlBlock+1} , {_ts, _ts+_controlBlock->size} };
mydestroy(arrays);
operator delete(_controlBlock);

[brenoguim]

Another implementation would be https://godbolt.org/z/nsMhd33ox . This seems to generate better code - using try/catch instead of destructors to ensure exception safety.
a bit of cleanup comes to this: https://godbolt.org/z/6zosWdeqb