Topic: RFC take 2: return type inference
Author: Matthew Woehlke <mwoehlke.floss@gmail.com>
Date: Fri, 29 Jan 2016 11:10:51 -0500
Raw View
This is a multi-part message in MIME format.
--------------010200050906090509090206
Content-Type: text/plain; charset=UTF-8
As requested, I have separated anonymous struct return from inferred
return type. The new version of the proposal (just the inferred return
type part) is attached.
Abstract: this proposal adds an additional case to the use of "auto" as
the return type specified, where the type is not deduced, but inferred
from a previous declaration:
int foo();
auto foo() { ... } // return type is 'int' due to prior declaration
I'm... considering submitting this version for the February mailing. I'm
concerned, however, that without the anonymous struct return, the
rationale is... lame. I'd appreciate any feedback or suggestions in this
respect. (TBH, I would really personally feel better submitting the
prior version instead. While the two ideas are separable, from a
rationale standpoint, they support each other.)
Online version:
https://github.com/mwoehlke/cpp-proposals/blob/master/dxxxx-implicit-return-type.rst
(As of writing, the link is currently the old version. I don't expect to
push the new version to the repo until the second paper is also ready;
at that point, however, the link will point to the new version.)
--
Matthew
--
---
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
Visit this group at https://groups.google.com/a/isocpp.org/group/std-proposals/.
--------------010200050906090509090206
Content-Type: text/prs.fallenstein.rst;
name="dxxxx-implicit-return-type.rst"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: attachment;
filename="dxxxx-implicit-return-type.rst"
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
Implicit Return Type
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
:Document: DXXXX (TBD)
:Date: 2016-01-29
:Project: ISO/IEC JTC1 SC22 WG21 Programming Language C++
:Audience: Evolution Working Group
:Author: Matthew Woehlke (mwoehlke.floss@gmail.com)
=2E. raw:: html
<style>
html { color: black; background: white; }
table.docinfo { margin: 2em 0; }
.literal-block { background: #eee; border: 1px solid #ddd; padding: 0=
=2E5em; }
.addition { color: #2c2; text-decoration: underline; }
.removal { color: #e22; text-decoration: line-through; }
.literal-block .literal-block { background: none; border: none; }
.block-addition { background: #cfc; text-decoration: underline; }
</style>
=2E. role:: add
:class: addition
=2E. role:: del
:class: removal
Abstract
=3D=3D=3D=3D=3D=3D=3D=3D
This proposal recommends an enhancement to return type deduction to allow=
the return type of a function definition to be inferred from a previous =
declaration of the same.
(Note: references made to the existing draft standard are made against N4=
567_.)
=2E. contents::
Rationale
=3D=3D=3D=3D=3D=3D=3D=3D=3D
The origin for this idea relates to multiple return values, and a desire =
to use anonymous structs to implement the same. This notion will be furth=
er explored in a different paper (for which this proposal would be a prer=
equisite). The obvious problem with anonymous struct returns involves sep=
arating the declaration of such a function from its definition; namely, h=
ow does one repeat the name of the return type? This lead to a more inter=
esting |--| and obvious in retrospect |--| question: since C++ functions =
(excluding templates) cannot be overloaded by their return value, **why i=
s it necessary to repeat the return value at all?**
Even in the case of return types that can be named, it may be that repeat=
ing the type name is excessively verbose or otherwise undesirable. Some m=
ight even call this a violation of the `Don't Repeat Yourself <https://en=
=2Ewikipedia.org/wiki/Don't_repeat_yourself>`_ principle, similar to some=
of the issues that ``auto`` for variable declaration was introduced to s=
olve. (On the flip side, one could see the ability to elide the return ty=
pe as subject to many abuses, again in much the manner of ``auto``. Howev=
er, many language features can be abused; this should not prevent the add=
ition of a feature that would provide an important benefit when used corr=
ectly.)
We would be remiss not to note that this is already possible in simple ca=
ses using ``decltype`` and a sample invocation of the function. However, =
while this may be adequate in simple cases, it is nevertheless needlessly=
verbose, and as the argument list grows longer, and/or gains arguments f=
or which providing a legal value is non-trivial, it can quickly become un=
wieldy and unfeasible.
Proposal
=3D=3D=3D=3D=3D=3D=3D=3D
Recent changes to the language have progressively relaxed the requirement=
s for how return types are specified. We began with trailing return type =
specification, and have progressed to inferred return types in certain ca=
ses.
This proposal is to continue this direction by adding an additional use o=
f ``auto`` as a return specifier, meaning "use the return type seen when =
this function was previously declared". The use of ``auto`` as the return=
type specifier, with no trailing return type, and for a function that ha=
s been previously declared with a known return type, shall instruct the c=
ompiler to define the function using the return type from the previous de=
claration.
Naturally, "previous declaration" here means a declaration having the sam=
e name and argument list. This, for example, would remain illegal:
=2E. code:: c++
int foo(int);
float foo(float);
auto foo(double input) // does not match any previous declaration
{
...
return result;
}
Proposed Wording
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
(Proposed changes are specified relative N4567_.)
Add a new section to [dcl.spec.auto] (7.1.6.4) as follows:
=2E. compound::
:class: literal-block block-addition
When a function is declared or defined using ``auto`` for the return ty=
pe, and a previous declaration or definition having a concrete return typ=
e exists, the return type shall be inferred to be the previously seen con=
crete type.
[*Example:*
.. parsed-literal::
std::string f();
auto f(); // OK, return type is std::string
|--| *end example*]
Add a new section to [dcl.spec.auto] (7.1.6.4) as follows:
=2E. compound::
:class: literal-block block-addition
A template function redeclaration or specialization having a return typ=
e of ``auto`` shall match a previous declaration (or definition) if the f=
irst such declaration had a concrete return type. If the first such decla=
ration also had a return type of ``auto``, the declaration using return t=
ype deduction shall be matched instead.
[*Example:*
.. parsed-literal::
template <typename T> T g(T t) { return t; } // #1
template auto g(float); // matches #1
template <typename T> auto g(T t) { return t; } // #2
template <typename T> T g(T t) { return t; }
template auto g(float); // matches #2
|--| *end example*]
Discussion
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
What about template return types?
---------------------------------
In C++14, the following code is legal and produces two distinct templates=
:
=2E. code:: c++
template <class T> int foo();
template <class T> auto foo();
This obviously conflicts with the proposed feature. After discussion on `=
`std-proposals``, it was decided that the proposed feature should take pr=
ecedence in this case. It should also be noted that it is unclear how, or=
even if, the second function can be invoked according to the current rul=
es of the language. (To this end, it may be desirable to simply forbid th=
e opposite ordering. However, we feel that this would be better addressed=
separately, perhaps even as a DR.)
Must the declaration providing the concrete type be the first declaration=
?
-------------------------------------------------------------------------=
-
This question was originally brought up by Bengt Gustafsson. Specifically=
, for the sake of symmetry, it seems initially desirable to allow:
=2E. code:: c++
int foo(); // specified return type
auto foo() { return 42; } // return type inferred from prior declaratio=
n
auto bar(); // forward declaration, type not yet known
int bar(); // specify the return type as 'int'
auto bar() { return 0; } // return type inferred from prior declaration=
To that end, earlier drafts of the proposal included the following propos=
ed change to [dcl.spec.auto]/13 (7.1.6.4.13):
=2E. compound::
:class: literal-block
Redeclarations or specializations of a function or function template wi=
th a declared return type that uses a placeholder type shall :del:`also u=
se that placeholder` :add:`use either that placeholder or a compatible co=
ncrete type`, not a deduced type. :add:`If the return type has previously=
been deduced, a declaration using a concrete type shall use the deduced =
type.`
[*Example:*
.. parsed-literal::
auto f();
auto f() { return 42; } // return type is int
auto f(); // OK
:del:`int f(); // error, cannot be overloaded with auto f()`
:add:`int f(); // OK, deduced type is also int`
decltype(auto) f(); // error, auto and decltype(auto) don't match
:add:`auto f(int);`
:add:`int f(int); // OK, return type of f(int) is now int`
:add:`float f(int); // error, redeclared with different return type`
However, upon further discussion, reservations were expressed, and the ge=
neral consensus seems to be that it is okay for the first declaration to =
"set in stone" if the return type will be known (and possibly later infer=
red), or deduced. Accordingly, absent the above change:
=2E. code:: c++
auto bar();
int bar(); // error, violates [dcl.spec.auto]/13
auto bar() { return 0; } // okay, but return type is deduced, not infer=
red
Acknowledgments
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
We wish to thank everyone on the ``std-proposals`` forum, especially Beng=
t Gustafsson and Tim Song, for their valuable feedback and insights.
References
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
=2E. _N4567: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n456=
7.pdf
* N4567_ Working Draft, Standard for Programming Language C++
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4567.pdf
=2E. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..=
.. ..
=2E. |--| unicode:: U+02014 .. em dash
=2E. kate: hl reStructuredText
--------------010200050906090509090206
Content-Type: text/html; charset=UTF-8;
name="dxxxx-implicit-return-type.html"
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
filename="dxxxx-implicit-return-type.html"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--------------010200050906090509090206--
.
Author: Moritz Klammler <moritz.klammler@gmail.com>
Date: Fri, 29 Jan 2016 18:09:58 +0100
Raw View
I didn't participate in the prior discussion so I'm sorry if I repeat
something that you have already discussed. Anyway, my first thought
when reading this example from your proposal
int foo(int);
float foo(float);
auto foo(double input) // does not match any previous declaration
{
...
return result;
}
was: Oh, this could be a nasty source of bugs. Let me re-write your
example a little.
float foo(double);
auto foo(double x)
{
return x;
}
Looking only at the definition, I could reasonably expect that `foo` has
a `return` type of `double` when actually it narrows it to a `float`.
This reminds me of the various gotchas you can run into when trying to
override `virtual` member functions and fail to match the signature
exactly.
If you think that this potential downside is overcompensated by the
gains, I think you should include a paragraph into your proposal to
mollify people who think like I did.
Did you consider adding an analogue to the `override` contextual keyword
such that one could write
float foo(double);
auto foo(double x) overlook
{
return x;
}
which would cause the compiler to refuse the code if there was no
previous declaration of `auto foo(double)`? It would also hint the
human reader that it is not `auto` type deduction that is going on here
and they should probably go and look for the preceding declaration.
You'll probably be able to come up with a better word than `overlook`...
Matthew Woehlke <mwoehlke.floss@gmail.com> writes:
> As requested, I have separated anonymous struct return from inferred
> return type. The new version of the proposal (just the inferred return
> type part) is attached.
>
> Abstract: this proposal adds an additional case to the use of "auto"
> as the return type specified, where the type is not deduced, but
> inferred from a previous declaration:
>
> int foo();
> auto foo() { ... } // return type is 'int' due to prior declaration
>
> I'm... considering submitting this version for the February
> mailing. I'm concerned, however, that without the anonymous struct
> return, the rationale is... lame. I'd appreciate any feedback or
> suggestions in this respect. (TBH, I would really personally feel
> better submitting the prior version instead. While the two ideas are
> separable, from a rationale standpoint, they support each other.)
>
> Online version:
> https://github.com/mwoehlke/cpp-proposals/blob/master/dxxxx-implicit-return-type.rst
>
> (As of writing, the link is currently the old version. I don't expect
> to push the new version to the repo until the second paper is also
> ready; at that point, however, the link will point to the new
> version.)
--
---
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
Visit this group at https://groups.google.com/a/isocpp.org/group/std-proposals/.
.
Author: Matthew Woehlke <mwoehlke.floss@gmail.com>
Date: Fri, 29 Jan 2016 12:59:32 -0500
Raw View
On 2016-01-29 12:09, Moritz Klammler wrote:
> I didn't participate in the prior discussion so I'm sorry if I repeat
> something that you have already discussed. Anyway, my first thought
> when reading this example from your proposal
>
> int foo(int);
> float foo(float);
>
> auto foo(double input) // does not match any previous declaration
> {
> ...
> return result;
> }
>
> was: Oh, this could be a nasty source of bugs. Let me re-write your
> example a little.
>
> float foo(double);
>
> auto foo(double x)
> {
> return x;
> }
>
> Looking only at the definition, I could reasonably expect that `foo` has
> a `return` type of `double` when actually it narrows it to a `float`.
1. Your compiler should warn you of this.
2. Don't do that?
I'm not really expecting people to use this for simple return types (in
fact, the original motivating case was for anonymous structs), but for
types that are a pain to write (i.e. 30+ characters long). As mentioned
in the paper, it can be abused, but so can 'auto' for variable
declarations. In many of the same ways, in fact.
> Did you consider adding an analogue to the `override` contextual keyword
> such that one could write
>
> float foo(double);
>
> auto foo(double x) overlook
> {
> return x;
> }
>
> which would cause the compiler to refuse the code if there was no
> previous declaration of `auto foo(double)`?
No, but it's an interesting idea. Given the time constraints, I don't
know if I'll be able to add that or not... We'll see.
> You'll probably be able to come up with a better word than `overlook`...
There are only two hard problems in programming: cache invalidation,
naming things, and off-by-one errors. This, alas, falls into the second
category. (IOW: suggestions welcomed :-).)
--
Matthew
--
---
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
Visit this group at https://groups.google.com/a/isocpp.org/group/std-proposals/.
.