On Thu, 29 Sept 2022 at 21:44, Arthur O'Dwyer <arthur.j.odwyer_at_[hidden]>
wrote:

> On Thu, Sep 29, 2022 at 3:57 PM Lénárd Szolnoki via Std-Proposals <
> std-proposals_at_[hidden]> wrote:
>
>> On 29 September 2022 20:25:06 BST, Edward Catmur <ecatmur_at_[hidden]>
>> wrote:
>> >On Thu, 29 Sept 2022 at 18:15, Lénárd Szolnoki via Std-Proposals <
>> std-proposals_at_[hidden]> wrote:
>> >
>> >> I think this could be addressed by two distinct proposals.
>> >>
>> >> 1. allow placeholders to appear in any deduced context
>> (std::vector<auto>)
>> >> 2. allow a placeholder to introduce a name (auto<class T>, auto<int i>
>> >> might appear as a deduced nttp)
>> >>
>> >> Then you can have your vector<auto<class T>> to deduce the value type
>> and
>> >> introduce the name T for that.
>> >
>> >std::vector<auto> is problematic, because elsewhere auto means a value of
>> >unconstrained type (e.g. in template<auto>).
>>
>> I disagree. auto is a placeholder for the type of the non-type parameter.
>> If you don't omit the name, then that name refers to the value.
>>
>
> FWIW, I tend to agree with Lénárd here: `auto *p, std::unique_ptr<auto> q`
> seems quite reasonable to me.
>

Ye-esss; looking at the grammar; `auto` is always a
placeholder-type-specifier, which is a simple-type-specifier, so it makes
sense that it takes the place of a concrete (or inferred) type.

So Lénárd, I apologise; you're correct that in these contexts `auto`
designates a type, not a value. I'm still trying to get my head round
"template<auto> int f();", but the syntax is clear.

*However*, I foresee practical problems with allowing auto *anywhere* in a
> declaration. Consider
> template<class T> void f(T t); // since C++98
> template<class T> void g(decltype(T(1)) t); // since C++11
> void f(auto t); // since C++20, equivalent to f #1
> void g(decltype(auto(1)) t); // since C++23, *not* equivalent to g #1
>
> Now, the `T` parameter to `g` is not deducible, so "obviously" the `auto`
> in g #2 doesn't mean the same thing as the `auto` in f #2. But are you sure
> we can teach that to the computer?
>
> (Background: I teach that `auto` since C++14 has (like most C++ keywords)
> had two meanings: concrete type *inference*, as in auto x = 1, and
> templatey type *deduction*, as in [](auto x){}. The physical mechanisms
> behind, and consequences of, these two usages of `auto` are vastly
> different, although their human-level meaning is similar: "I don't want to
> bother with types; compiler, please figure it out." So if you see me
> talking about "inference" versus "deduction," or "the first meaning of
> auto" versus "the second meaning of auto," that's what I'm talking about.)
>

The deduction process is ultimately the same; both end up in
temp.deduct.call. In an abbreviated function template or generic lambda,
the deduction can be overridden by explicit template argument, but that's a
relatively minor effect. And syntactically, they're the same; a
decl-specifier of a decl-specifier-seq (of a function parameter or variable
declaration); `auto` in a function return type or trailing return type has
less in common, though I'd suppose you'd class that as inference. Still, I
guess it's OK to teach it that way.

It would certainly *not* be reasonable to have a rule like "Try to
> interpret every `auto` as deduction, but if that would result in a
> non-deducible template parameter, then backtrack and assume it's inference
> instead." It would be reasonable to have a rule that boils down to "Inside
> the operand of a decltype or sizeof or array bound, the `auto` always means
> inference not deduction." But is `g` above the *only* problem case? Are
> there other corner cases where `auto` is already legal today, and/or we
> wouldn't want it to mean a template parameter?
> void f(A<auto(int())>); // is this concrete A<0> or templatey
> A<T(int())>? I guess the type of A will disambiguate...
>

Currently a placeholder can appear as the decl-specifier of a function
parameter, variable declaration, or template parameter or, as exactly one
simple-type-specifier of a return or trailing return type,
conversion function id, new expression's type id, or (`auto` only) as the
type specifier of a functional cast. If these were relaxed, I think we'd
probably be OK; you just go through inventing extra type template
parameters and perform deduction as usual.

Also I don't think ambiguity *can* be an issue, or it would be already;
there must be disambiguators in the syntax. Indeed, I have a strong
suspicion that your `A<auto(int())>` is a most vexing parse.

Also consider that while
> void h1(std::vector<auto, auto> v);
> would work fine with Lénárd's proposed syntax,
> void h2(std::array<auto, ??> a);
> would not. That does seem mildly problematic. However, maybe it's
> consistent with C++20, which permits
> template<class T> concept Integral = true;
> template<Integral T> void ij(); // since C++20
> but not
> template<int N> concept Odd = true;
> template<Odd N> void ij(); // error: Odd does not constrain a type
>

Yes, fair enough; this does conform to the grammar.