I would like to semi-formally propose a defect report related to std::array
and existing standards.

It turns out std::array<T, 0> cannot be implemented in C++17 without the
use of magic compiler builtins. libc++, libstdc++, and I think also MSVC
are all non-compliant.

Begin and end are required to return a unique pointer, the only constexpr
method I have found to do this is taking the address of a union member.
However, that approach breaks if T is non-trivial.

Glibc libstdc++ libc++ ignores the standard requirement of uniqueness in
favor of following the trivial and constexpr requirements. Both of these
implementations return nullptr.

Second, libc++ didn't use a single empty aggregate (this might force an ABI
break), not sure if that one was adopted in the standard, but that should
not be included in a standard. glibc libstdc++ follows this requirement,
but it's an ABI break for libc++.

There are, as I see it, three possible solutions:

1. Remove the "uniqueness" requirement from std::array<T, 0>::begin and
::end, (only in the case where N=0) and drop the empty aggregate
requirement from new versions of the standard. This would make libstdc++
and libc++'s implementation returning nullptr standard compliant by
changing the standard. Least disruptive solution.

2. Extend the "is_trivial" logic to allow initializers that
initialize empty aggregates to not make the class be considered
non-trivial, e.g.

struct empty {};
struct foo { empty e = {}; }

Here, `foo` could become considered a trivial type.

However, this might break existing code that relies on is_trivial, so I
think that is a bad solution for existing C++ versions. Though I doubt any
code would actually break? This might be a good idea to explore for C++26
though as I don't see any downside to making this trivial aside from any
rare corner case of a library that depends on this non-triviality.

3. Drop the deleted union destructors for non-trivial types. I like this
solution a lot but there is some code breakage possibility.

plus the bonus non-solution,

4. implement some compiler builtin that can be used as a weird hack to
implement the std::array<T, 0> standardized behavior and get every compiler
that wants to use libc++ to implement it.