On Wed, Nov 4, 2020 at 3:58 PM D'Alessandro, Luke K <ldalessa@iu.edu> wrote:
On Nov 4, 2020, at 11:54 AM, Arthur O'Dwyer <arthur.j.odwyer@gmail.com> wrote:
On Wed, Nov 4, 2020 at 2:22 PM D'Alessandro, Luke K <ldalessa@iu.edu> wrote:
Hi Arthur,

On Nov 4, 2020, at 10:46 AM, Arthur O'Dwyer via Std-Proposals <std-proposals@lists.isocpp.org> wrote:
If you're trying to use std::to_array with explicit template arguments, as in
    auto f3 = std::to_array<float>({1, 2, 3});
    auto f0 = std::to_array<float>({});
then I think that usage needs justification (by which I actually mean, that usage is wrong).
This is the use case that occurs with some frequency in real code, and is explicitly referenced numerous times in http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0325r3.html. I don’t feel like it is wrong.

I do. :)
I see it mentioned once in p0325r4's examples (but never called out as a primary use-case), and zero times in the actual paper standard.

We must be looking at different versions of r4 then (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0325r4.html). It’s prominent in the introduction and appears a number of times in the impact on the standard.

Hm, yes, it's mentioned several times. Okay.

Anyway, I would be mildly surprised if your code couldn't also benefit from the advice in
I’m not sure if this is snark or self promotion or an actual attempt to be helpful. Given the emoji I assume a bit of the first two, not much of the third.

Well, the post's advice is orthogonal to your original proposal about std::to_array<T>({}) — but, IMO, that original problem is completely solved by saying "just use std::array<T,0>{} or std::array<T,sizeof...(args)>{args...} as appropriate, which has the benefit of speeding up your code."  My advice to for additional speedup, additionally stop using std::array may not be immediately actionable for you.
If you're able to follow the advice in the post (such as "avoid std::array" and "avoid manually counting array elements"), it might be very helpful. But I suspect that you might be operating in a domain, or on an arcanely tangled codebase, where advice of the form "Just don't do X" doesn't count as helpful.
[from blog]
Anyway, all of these options result in a lot of extra template instantiations, compared to plain old C-style arrays (which require zero template instantiations). Therefore I strongly prefer T[] over std::array<T, N>.
Indeed. I would much prefer to use a C array (+span as necessary) in my generic constexpr code, but the the context happens to sometimes be zero-length. I have considered (am strongly considering) enabling zero-length-array extensions as the alternative to std::array.

–Arthur