meaning

On Sun, Jun 13, 2021 at 8:17 AM Михаил Найденов via Std-Proposals
<std-proposals_at_[hidden]> wrote:
>
> Any objections and/or comments, pursuing this (for 23)? Thank You

It's kind of hard to read, as it's an HTML document on OneDrive being
rendered as... plain text. So to read it, you basically have to
download it.

After downloading, I have some commentary:

> Abbreviated Arguments Part 1

You're using the words the wrong way. You consistently do it, but it's
consistently wrong, right down to the title: "Argument" refers to the
expression used to initialize a function's "parameters". What you're
declaring in a function declaration are *parameters*, not "arguments".

> Introduce a slightly different syntax to donate Abbreviated Arguments:

"denote", not "donate".

> The above declaration is equivalent to:

```
template<class T>
auto something(T <qualifiers> string, const vector& v);
```

> Function template. <qualifiers> are discussed in Part 2.

Well, without "Part 2" in hand, how can we evaluate the meaning of
"Part 1"? How meaningful it is depends *entirely* on how those
qualifiers are generated.

Remember: the whole point of this proposal is to make function
prototypes shorter where needed. But "needed" depends entirely on how
you generate qualifiers. To use your example:

```
  [](const auto& fruit, const auto& basket) { return fruit + ": " +
std::to_string(basket.size());
// to (this proposal)
  []((fruit, basket)) { return fruit + ": " + std::to_string(basket.size());
```

OK, so you've decided that `fruit` is an `auto const&`. So... what do
I do if I want to modify it? Or if I want to forward it? Do I have to
go back to `auto`, or can I just say `&&fruit`? And if I can... how
helpful is that compared to just using `auto &&`?

Remember: the principle use case is short lambdas. And I would argue
that short lambdas are the ones *most likely* to want to forward their
parameters. So the argument could be made that you're not making that
code appreciably shorter.

But I don't know if that's true since you never actually say how this
gets figured out. Until you do, it's just half a proposal. And we
can't evaluate half of a proposal.

> This is ignoring the fact, `auto&&` is somewhat of a geek, "too clever" option in my opinion.

It's not. C++ programmers need to get used to seeing and using it.
Especially in template code where you'll be doing a lot of forwarding
or in range-based `for` loops that want to work with proxy iterators.
See this for more:
https://stackoverflow.com/questions/51461281/range-ts-idioms-and-the-mysterious-auto