------=_Part_42_901408049.1443036768536
Content-Type: multipart/alternative;
 boundary="----=_Part_43_1875062311.1443036768536"

------=_Part_43_1875062311.1443036768536
Content-Type: text/plain; charset=UTF-8

I propose to introduce the *returntype *keyword, which will represent the
return type of the current function.

The aim is
(1) to define a local variable, which will be used to return the value of
the function.
(2) to convert an expression to the value of the return type.

In practice, it is convenient to use when you want to change the return
type without restructuring the whole function body.

struct Type2 { explicit Type2(int){} };

Type2 f2_braces()
{
    returntype local2{2}; // ok
    return local2; //

    ...
    return returntype{10}; // ok
}

If I want to change Type2 to Type3 I need only to change the function
header without touching the body.



--

---
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 http://groups.google.com/a/isocpp.org/group/std-proposals/.

------=_Part_43_1875062311.1443036768536
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div>I propose to introduce the <strong>returntype </stron=
g>keyword, which will represent the return type of the current function.</d=
iv><div><br></div><div>The aim is </div><div>(1) to define a local variable=
, which will be used to return the value of the function.</div><div>(2) to =
convert an expression to the value of the return type.</div><div><br></div>=
<div>In practice, it is convenient to use when you want to change the retur=
n type without restructuring the whole function body.</div><div><br></div><=
div>struct Type2 { explicit Type2(int){} };<br></div><div><br></div><div>Ty=
pe2 f2_braces() <br>{<br>=C2=A0=C2=A0=C2=A0 returntype local2{2}; // ok</di=
v><div>=C2=A0=C2=A0=C2=A0 return local2; //</div><div><br></div><div>=C2=A0=
=C2=A0=C2=A0 ...<br>=C2=A0=C2=A0=C2=A0 return returntype{10}; // ok<br>}</d=
iv><div><br></div><div>If I want to change Type2 to Type3 I need only to ch=
ange the function header without touching the body.</div><div><br></div><di=
v><br></div><div><br></div></div>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

------=_Part_43_1875062311.1443036768536--
------=_Part_42_901408049.1443036768536--

.

--001a113f89de8832b405206f51a6
Content-Type: text/plain; charset=UTF-8

In the use case (1), why wouldn't we use decltype?

In your example:

2015-09-23 16:32 GMT-03:00 Mikhail Semenov <mikhailsemenov1957@gmail.com>:

> I propose to introduce the *returntype *keyword, which will represent the
> return type of the current function.
>
> The aim is
> (1) to define a local variable, which will be used to return the value of
> the function.
> (2) to convert an expression to the value of the return type.
>
> In practice, it is convenient to use when you want to change the return
> type without restructuring the whole function body.
>
> struct Type2 { explicit Type2(int){} };
>
> Type2 f2_braces()
> {
>     //returntype local2{2}; // ok
>
        decltype(f2_braces()) local2{2}; // works just as well, replacing
the line above.

>     return local2; //
>
>     ...
>     return returntype{10}; // ok
> }
>
> If I want to change Type2 to Type3 I need only to change the function
> header without touching the body.
>
>
>
> --
>
> ---
> 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
> http://groups.google.com/a/isocpp.org/group/std-proposals/.
>

--

---
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 http://groups.google.com/a/isocpp.org/group/std-proposals/.

--001a113f89de8832b405206f51a6
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">In the use case (1), why wouldn&#39;t we use decltype?<div=
><br></div><div>In your example:</div><div class=3D"gmail_extra"><br><div c=
lass=3D"gmail_quote">2015-09-23 16:32 GMT-03:00 Mikhail Semenov <span dir=
=3D"ltr">&lt;<a href=3D"mailto:mikhailsemenov1957@gmail.com" target=3D"_bla=
nk">mikhailsemenov1957@gmail.com</a>&gt;</span>:<br><blockquote class=3D"gm=
ail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left-width:1px;border-l=
eft-color:rgb(204,204,204);border-left-style:solid;padding-left:1ex"><div d=
ir=3D"ltr"><div>I propose to introduce the <strong>returntype </strong>keyw=
ord, which will represent the return type of the current function.</div><di=
v><br></div><div>The aim is </div><div>(1) to define a local variable, whic=
h will be used to return the value of the function.</div><div>(2) to conver=
t an expression to the value of the return type.</div><div><br></div><div>I=
n practice, it is convenient to use when you want to change the return type=
 without restructuring the whole function body.</div><div><br></div><div>st=
ruct Type2 { explicit Type2(int){} };<br></div><div><br></div><div>Type2 f2=
_braces() <br>{<br>=C2=A0 =C2=A0 //returntype local2{2}; // ok</div></div><=
/blockquote><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 decltype(f2_braces()) local2{2=
}; // works just as well, replacing the line above.</div><blockquote class=
=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left-width:1px;bo=
rder-left-color:rgb(204,204,204);border-left-style:solid;padding-left:1ex">=
<div dir=3D"ltr"><div>=C2=A0=C2=A0=C2=A0 return local2; //</div><div><br></=
div><div>=C2=A0=C2=A0=C2=A0 ...<br>=C2=A0=C2=A0=C2=A0 return returntype{10}=
; // ok<br>}</div><div><br></div><div>If I want to change Type2 to Type3 I =
need only to change the function header without touching the body.</div><sp=
an class=3D""><font color=3D"#888888"><div><br></div><div><br></div><div><b=
r></div></font></span></div><span class=3D""><font color=3D"#888888">

<p></p>

-- <br>
<br>
--- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br>
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/" target=3D"_blank">http://groups.google.com/a/isocpp.org/gro=
up/std-proposals/</a>.<br>
</font></span></blockquote></div><br></div></div>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

--001a113f89de8832b405206f51a6--

.

On 2015-09-23 15:32, Mikhail Semenov wrote:
> I propose to introduce the *returntype *keyword, which will represent the
> return type of the current function.
>
> The aim is
> (1) to define a local variable, which will be used to return the value of
> the function.
> (2) to convert an expression to the value of the return type.

New keywords are *really hard* to get approved due to the possibility of
breaking things. I don't see a need here; something like
'decltype(return)' would work just as well and can't break existing code.

I do think this would be useful; while Pablo's suggestion works in
simple cases, it's much more awkward in the case of overloaded functions
(and, I think, wouldn't work at all inside a lambda).

--
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 http://groups.google.com/a/isocpp.org/group/std-proposals/.

.

--089e011843e82827ba05206fd0da
Content-Type: text/plain; charset=UTF-8

I agree decltype(return)  is probably even better.
I was thinking even "typename return", but its a bit long and confusing.

Type2 f2_braces()
{
    decltype(return) local2{2}; // ok
    return local2; //

    ...
    return decltype(return){10}; // conversion to the parameter type
}

On 23 September 2015 at 20:52, Matthew Woehlke <mwoehlke.floss@gmail.com>
wrote:

> On 2015-09-23 15:32, Mikhail Semenov wrote:
> > I propose to introduce the *returntype *keyword, which will represent the
> > return type of the current function.
> >
> > The aim is
> > (1) to define a local variable, which will be used to return the value of
> > the function.
> > (2) to convert an expression to the value of the return type.
>
> New keywords are *really hard* to get approved due to the possibility of
> breaking things. I don't see a need here; something like
> 'decltype(return)' would work just as well and can't break existing code.
>
> I do think this would be useful; while Pablo's suggestion works in
> simple cases, it's much more awkward in the case of overloaded functions
> (and, I think, wouldn't work at all inside a lambda).
>
> --
> 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
> http://groups.google.com/a/isocpp.org/group/std-proposals/.
>

--

---
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 http://groups.google.com/a/isocpp.org/group/std-proposals/.

--089e011843e82827ba05206fd0da
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div>I agree decltype(return)=C2=A0 is probably even bette=
r.</div><div>I was thinking even &quot;typename return&quot;, but its a bit=
 long and confusing.</div><div><br></div><div><div>Type2 f2_braces() <br>{<=
br>=C2=A0=C2=A0=C2=A0 decltype(return) local2{2}; // ok</div><div>=C2=A0=C2=
=A0=C2=A0 return local2; //</div><div><br></div><div>=C2=A0=C2=A0=C2=A0 ...=
<br>=C2=A0=C2=A0=C2=A0 return decltype(return){10}; // conversion to the pa=
rameter type<br>}</div></div></div><div class=3D"gmail_extra"><br><div clas=
s=3D"gmail_quote">On 23 September 2015 at 20:52, Matthew Woehlke <span dir=
=3D"ltr">&lt;<a href=3D"mailto:mwoehlke.floss@gmail.com" target=3D"_blank">=
mwoehlke.floss@gmail.com</a>&gt;</span> wrote:<br><blockquote class=3D"gmai=
l_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left=
:1ex">On 2015-09-23 15:32, Mikhail Semenov wrote:<br>
&gt; I propose to introduce the *returntype *keyword, which will represent =
the<br>
<span>&gt; return type of the current function.<br>
&gt;<br>
&gt; The aim is<br>
&gt; (1) to define a local variable, which will be used to return the value=
 of<br>
&gt; the function.<br>
&gt; (2) to convert an expression to the value of the return type.<br>
<br>
</span>New keywords are *really hard* to get approved due to the possibilit=
y of<br>
breaking things. I don&#39;t see a need here; something like<br>
&#39;decltype(return)&#39; would work just as well and can&#39;t break exis=
ting code.<br>
<br>
I do think this would be useful; while Pablo&#39;s suggestion works in<br>
simple cases, it&#39;s much more awkward in the case of overloaded function=
s<br>
(and, I think, wouldn&#39;t work at all inside a lambda).<br>
<span class=3D"HOEnZb"><font color=3D"#888888"><br>
--<br>
Matthew<br>
</font></span><div class=3D"HOEnZb"><div class=3D"h5"><br>
--<br>
<br>
---<br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals%2Bunsubscribe@isocpp.org">std-propo=
sals+unsubscribe@isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br>
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/" target=3D"_blank" rel=3D"noreferrer">http://groups.google.c=
om/a/isocpp.org/group/std-proposals/</a>.<br>
</div></div></blockquote></div><br></div>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

--089e011843e82827ba05206fd0da--

.

On Wednesday 23 September 2015 21:18:09 Mikhail Semenov wrote:
> I agree decltype(return)  is probably even better.
> I was thinking even "typename return", but its a bit long and confusing.
>
> Type2 f2_braces()
> {
>     decltype(return) local2{2}; // ok
>     return local2; //
>
>     ...
>     return decltype(return){10}; // conversion to the parameter type
> }

You may want to instead introduce a decltype(thisfunction) which returns the
full function type, as it would be useful in disambiguating contexts too:

 auto fptr = static_cast<decltype(thisfunction) *>(otherFunction);

The return type would be decltype(thisfunction()) for nullary functions and
would could obtained by std::function_traits for non-nullary.
--
Thiago Macieira - thiago (AT) macieira.info - thiago (AT) kde.org
   Software Architect - Intel Open Source Technology Center
      PGP/GPG: 0x6EF45358; fingerprint:
      E067 918B B660 DBD1 105C  966C 33F5 F005 6EF4 5358

--

---
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 http://groups.google.com/a/isocpp.org/group/std-proposals/.

.

--001a11c3463887d430052072c41c
Content-Type: text/plain; charset=UTF-8

On 23 September 2015 at 22:18, Mikhail Semenov <mikhailsemenov1957@gmail.com
> wrote:

> Type2 f2_braces()
> {
>     decltype(return) local2{2}; // ok
>     return local2; //
>
>     ...
>     return decltype(return){10}; // conversion to the parameter type
> }
>

I jokingly started to imagine this:

template< calss A, class B >
auto compute(A a, B b)
{
    vector<decltype(return)> values;
    for(int i = 0; i < 1234)
         values.push_back( a * b ); // a * b might return  something
different from A or B

    random_shuffle(values);

    return values.first();
}

Which would avoid having to have a potentially complex expression in the
signature or in the vector type.

Interesting.

--

---
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 http://groups.google.com/a/isocpp.org/group/std-proposals/.

--001a11c3463887d430052072c41c
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div class=3D"gmail_extra"><br><div class=3D"gmail_quote">=
On 23 September 2015 at 22:18, Mikhail Semenov <span dir=3D"ltr">&lt;<a hre=
f=3D"mailto:mikhailsemenov1957@gmail.com" target=3D"_blank">mikhailsemenov1=
957@gmail.com</a>&gt;</span> wrote:<br><blockquote class=3D"gmail_quote" st=
yle=3D"margin:0px 0px 0px 0.8ex;border-left-width:1px;border-left-color:rgb=
(204,204,204);border-left-style:solid;padding-left:1ex"><div>Type2 f2_brace=
s() <br>{<br>=C2=A0=C2=A0=C2=A0 decltype(return) local2{2}; // ok</div><div=
>=C2=A0=C2=A0=C2=A0 return local2; //</div><div><br></div><div>=C2=A0=C2=A0=
=C2=A0 ...<br>=C2=A0=C2=A0=C2=A0 return decltype(return){10}; // conversion=
 to the parameter type<br>}</div></blockquote></div><br>I jokingly started =
to imagine this:</div><div class=3D"gmail_extra"><br></div><div class=3D"gm=
ail_extra">template&lt; calss A, class B &gt;</div><div class=3D"gmail_extr=
a"><div class=3D"gmail_extra">auto compute(A a, B b)=C2=A0</div><div class=
=3D"gmail_extra">{</div><div class=3D"gmail_extra">=C2=A0 =C2=A0 vector&lt;=
decltype(return)&gt; values;</div><div class=3D"gmail_extra">=C2=A0 =C2=A0 =
for(int i =3D 0; i &lt; 1234)</div><div class=3D"gmail_extra">=C2=A0 =C2=A0=
 =C2=A0 =C2=A0 =C2=A0values.push_back( a * b ); // a * b might return =C2=
=A0something different from A or B</div><div class=3D"gmail_extra"><br></di=
v><div class=3D"gmail_extra">=C2=A0 =C2=A0 random_shuffle(values);</div><di=
v class=3D"gmail_extra">=C2=A0 =C2=A0=C2=A0</div><div class=3D"gmail_extra"=
>=C2=A0 =C2=A0 return values.first();</div><div class=3D"gmail_extra">}</di=
v><div class=3D"gmail_extra"><br></div><div class=3D"gmail_extra">Which wou=
ld avoid having to have a potentially complex expression in the signature o=
r in the vector type.</div><div class=3D"gmail_extra"><br></div><div class=
=3D"gmail_extra">Interesting.</div><div class=3D"gmail_extra"><br></div></d=
iv></div>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

--001a11c3463887d430052072c41c--

.

--001a11c26804671f72052072c7a4
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

On 24 September 2015 at 01:49, Klaim - Jo=C3=ABl Lamotte <mjklaim@gmail.com=
>
wrote:

> I jokingly started to imagine this:
>
> template< calss A, class B >
> auto compute(A a, B b)
> {
>     vector<decltype(return)> values;
>     for(int i =3D 0; i < 1234)
>          values.push_back( a * b ); // a * b might return  something
> different from A or B
>
>     random_shuffle(values);
>
>     return values.first();
> }
>
> Which would avoid having to have a potentially complex expression in the
> signature or in the vector type.
>
> Interesting.
>

Wait no, I just realized re-reading that the vector type cannot be deduced.
Too bad.

--=20

---=20
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 e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposa=
ls/.

--001a11c26804671f72052072c7a4
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div class=3D"gmail_extra"><br><div class=3D"gmail_quote">=
On 24 September 2015 at 01:49, Klaim - Jo=C3=ABl Lamotte <span dir=3D"ltr">=
&lt;<a href=3D"mailto:mjklaim@gmail.com" target=3D"_blank">mjklaim@gmail.co=
m</a>&gt;</span> wrote:<br><blockquote class=3D"gmail_quote" style=3D"margi=
n:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div class=3D"gma=
il_extra">I jokingly started to imagine this:</div><div class=3D"gmail_extr=
a"><br></div><div class=3D"gmail_extra">template&lt; calss A, class B &gt;<=
/div><div class=3D"gmail_extra"><div class=3D"gmail_extra">auto compute(A a=
, B b)=C2=A0</div><div class=3D"gmail_extra">{</div><div class=3D"gmail_ext=
ra">=C2=A0 =C2=A0 vector&lt;decltype(return)&gt; values;</div><div class=3D=
"gmail_extra">=C2=A0 =C2=A0 for(int i =3D 0; i &lt; 1234)</div><div class=
=3D"gmail_extra">=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0values.push_back( a * b =
); // a * b might return =C2=A0something different from A or B</div><div cl=
ass=3D"gmail_extra"><br></div><div class=3D"gmail_extra">=C2=A0 =C2=A0 rand=
om_shuffle(values);</div><div class=3D"gmail_extra">=C2=A0 =C2=A0=C2=A0</di=
v><div class=3D"gmail_extra">=C2=A0 =C2=A0 return values.first();</div><div=
 class=3D"gmail_extra">}</div><div class=3D"gmail_extra"><br></div><div cla=
ss=3D"gmail_extra">Which would avoid having to have a potentially complex e=
xpression in the signature or in the vector type.</div><div class=3D"gmail_=
extra"><br></div><div class=3D"gmail_extra">Interesting.</div></div></block=
quote></div><br>Wait no, I just realized re-reading that the vector type ca=
nnot be deduced. Too bad.</div><div class=3D"gmail_extra"><br></div></div>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

--001a11c26804671f72052072c7a4--

.

------=_Part_116_1157043219.1443104279021
Content-Type: multipart/alternative;
 boundary="----=_Part_117_88273961.1443104279022"

------=_Part_117_88273961.1443104279022
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

You either have one or the other: the type of the function is either=20
defined (and you can use decltype(return)) or  deduced (you cannot use=20
decltype(return)).

On Thursday, September 24, 2015 at 12:50:29 AM UTC+1, Klaim - Jo=C3=ABl Lam=
otte=20
wrote:

>
> On 24 September 2015 at 01:49, Klaim - Jo=C3=ABl Lamotte <mjk...@gmail.co=
m=20
> <javascript:>> wrote:
>
>> I jokingly started to imagine this:
>>
>> template< calss A, class B >
>> auto compute(A a, B b)=20
>> {
>>     vector<decltype(return)> values;
>>     for(int i =3D 0; i < 1234)
>>          values.push_back( a * b ); // a * b might return  something=20
>> different from A or B
>>
>>     random_shuffle(values);
>>    =20
>>     return values.first();
>> }
>>
>> Which would avoid having to have a potentially complex expression in the=
=20
>> signature or in the vector type.
>>
>> Interesting.
>>
>
> Wait no, I just realized re-reading that the vector type cannot be=20
> deduced. Too bad.
>
>

--=20

---=20
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 e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposa=
ls/.

------=_Part_117_88273961.1443104279022
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div>You either have one or the other: the type of the fun=
ction is either defined (and you can use decltype(return)) or=C2=A0 deduced=
 (you cannot use decltype(return)).</div><div><br>On Thursday, September 24=
, 2015 at 12:50:29 AM UTC+1, Klaim - Jo=C3=ABl Lamotte wrote:</div><blockqu=
ote class=3D"gmail_quote" style=3D"margin: 0px 0px 0px 0.8ex; padding-left:=
 1ex; border-left-color: rgb(204, 204, 204); border-left-width: 1px; border=
-left-style: solid;"><div dir=3D"ltr"><div><br><div class=3D"gmail_quote">O=
n 24 September 2015 at 01:49, Klaim - Jo=C3=ABl Lamotte <span dir=3D"ltr">&=
lt;<a onmousedown=3D"this.href=3D&#39;javascript:&#39;;return true;" onclic=
k=3D"this.href=3D&#39;javascript:&#39;;return true;" href=3D"javascript:" t=
arget=3D"_blank" rel=3D"nofollow" gdf-obfuscated-mailto=3D"RXyb1AB8BgAJ">mj=
k...@gmail.com</a>&gt;</span> wrote:<br><blockquote class=3D"gmail_quote" s=
tyle=3D"margin: 0px 0px 0px 0.8ex; padding-left: 1ex; border-left-color: rg=
b(204, 204, 204); border-left-width: 1px; border-left-style: solid;"><div>I=
 jokingly started to imagine this:</div><div><br></div><div>template&lt; ca=
lss A, class B &gt;</div><div><div>auto compute(A a, B b)=C2=A0</div><div>{=
</div><div>=C2=A0 =C2=A0 vector&lt;decltype(return)&gt; values;</div><div>=
=C2=A0 =C2=A0 for(int i =3D 0; i &lt; 1234)</div><div>=C2=A0 =C2=A0 =C2=A0 =
=C2=A0 =C2=A0values.push_back( a * b ); // a * b might return =C2=A0somethi=
ng different from A or B</div><div><br></div><div>=C2=A0 =C2=A0 random_shuf=
fle(values);</div><div>=C2=A0 =C2=A0=C2=A0</div><div>=C2=A0 =C2=A0 return v=
alues.first();</div><div>}</div><div><br></div><div>Which would avoid havin=
g to have a potentially complex expression in the signature or in the vecto=
r type.</div><div><br></div><div>Interesting.</div></div></blockquote></div=
><br>Wait no, I just realized re-reading that the vector type cannot be ded=
uced. Too bad.</div><div><br></div></div>
</blockquote></div>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

------=_Part_117_88273961.1443104279022--
------=_Part_116_1157043219.1443104279021--

.

------=_Part_2223_1287738834.1443445317043
Content-Type: multipart/alternative;
 boundary="----=_Part_2224_813007833.1443445317043"

------=_Part_2224_813007833.1443445317043
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

I do agree with Mikhail Semenov, a* returntype* keyword would be nice

Note that:
SomeType foo(SomeArgTypes... someArgs)
{
decltype(foo(someArgs)) toReturn;
.....
return toReturn;
}

is only a partial and error prone solution, as you have to modify=20
"SomeArgs" two times:
 - function prototype
 - decltype(...)
if you have to modify foo arguments.

Le mercredi 23 septembre 2015 21:32:48 UTC+2, Mikhail Semenov a =C3=A9crit =
:
>
> I propose to introduce the *returntype *keyword, which will represent the=
=20
> return type of the current function.
>
> The aim is=20
> (1) to define a local variable, which will be used to return the value of=
=20
> the function.
> (2) to convert an expression to the value of the return type.
>
> In practice, it is convenient to use when you want to change the return=
=20
> type without restructuring the whole function body.
>
> struct Type2 { explicit Type2(int){} };
>
> Type2 f2_braces()=20
> {
>     returntype local2{2}; // ok
>     return local2; //
>
>     ...
>     return returntype{10}; // ok
> }
>
> If I want to change Type2 to Type3 I need only to change the function=20
> header without touching the body.
>
>
>
>

--=20

---=20
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 e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposa=
ls/.

------=_Part_2224_813007833.1443445317043
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">I do agree with <span class=3D"_username"><span style=3D"c=
olor: rgb(34, 34, 34);" class=3D"CMTFO4B-N-a">Mikhail Semenov</span></span>=
, a<b> returntype</b> keyword would be nice<br><br>Note that:<br>SomeType f=
oo(SomeArgTypes... someArgs)<br>{<br>decltype(foo(someArgs)) toReturn;<br>.=
....<br>return toReturn;<br>}<br><br>is only a partial and error prone solut=
ion, as you have to modify &quot;SomeArgs&quot; two times:<br>=C2=A0- funct=
ion prototype<br>=C2=A0- decltype(...)<br>if you have to modify foo argumen=
ts.<br><br>Le mercredi 23 septembre 2015 21:32:48 UTC+2, Mikhail Semenov a =
=C3=A9crit=C2=A0:<blockquote class=3D"gmail_quote" style=3D"margin: 0;margi=
n-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"l=
tr"><div>I propose to introduce the <b>returntype </b>keyword, which will r=
epresent the return type of the current function.</div><div><br></div><div>=
The aim is </div><div>(1) to define a local variable, which will be used to=
 return the value of the function.</div><div>(2) to convert an expression t=
o the value of the return type.</div><div><br></div><div>In practice, it is=
 convenient to use when you want to change the return type without restruct=
uring the whole function body.</div><div><br></div><div>struct Type2 { expl=
icit Type2(int){} };<br></div><div><br></div><div>Type2 f2_braces() <br>{<b=
r>=C2=A0=C2=A0=C2=A0 returntype local2{2}; // ok</div><div>=C2=A0=C2=A0=C2=
=A0 return local2; //</div><div><br></div><div>=C2=A0=C2=A0=C2=A0 ...<br>=
=C2=A0=C2=A0=C2=A0 return returntype{10}; // ok<br>}</div><div><br></div><d=
iv>If I want to change Type2 to Type3 I need only to change the function he=
ader without touching the body.</div><div><br></div><div><br></div><div><br=
></div></div></blockquote></div>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

------=_Part_2224_813007833.1443445317043--
------=_Part_2223_1287738834.1443445317043--

.

------=_Part_6783_1396604305.1443495681557
Content-Type: multipart/alternative;
 boundary="----=_Part_6784_799715845.1443495681564"

------=_Part_6784_799715845.1443495681564
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

Could someone who's in favor of this idea post an example of actual code=20
(from an actual codebase) where this shortcut would be useful? In my=20
opinion, all the examples thus far have either
- used simple typedefs like "Type2" or "SomeType" which are no trouble at=
=20
all to repeat, or
- been amenable to a simple "return { initializer };" without any local=20
variable declaration at all, or
- been amenable to using "auto" return type deduction to eliminate the=20
repetition, or
- some combination of the above.

In other words, the cost of this feature is high; can someone show that the=
=20
potential benefit is equally high?

Also =E2=80=94 this isn't a killer, but =E2=80=94 it seems awkward to have =
*both* "parse=20
the body of the function to deduce the auto return type" *and* "while=20
parsing the body of a function, replace decltype(return) with the return=20
type of the function" in the same language.

If the compiler mechanisms were available to implement this feature, I'd=20
suggest going the whole way and providing access to "the current function",=
=20
something kind of like letrec <https://duckduckgo.com/?q=3D%22letrec%22>, o=
r=20
like *__func__* except without the quotation marks around it. This would=20
let us implement things like

    auto fact =3D [](int x) { return x > 1 ? x * __curfunc__(x) : 1; };

and would make *decltype(return)* exactly equivalent to=20
*std::function<decltype(__cur_func__)>::result_type*.

=E2=80=93Arthur=20

On Monday, September 28, 2015 at 6:01:57 AM UTC-7, Vincent Picaud wrote:
>
> I do agree with Mikhail Semenov, a* returntype* keyword would be nice
>
> Note that:
> SomeType foo(SomeArgTypes... someArgs)
> {
> decltype(foo(someArgs)) toReturn;
> ....
> return toReturn;
> }
>
> is only a partial and error prone solution, as you have to modify=20
> "SomeArgs" two times:
>  - function prototype
>  - decltype(...)
> if you have to modify foo arguments.
>
> Le mercredi 23 septembre 2015 21:32:48 UTC+2, Mikhail Semenov a =C3=A9cri=
t :
>>
>> I propose to introduce the *returntype *keyword, which will represent=20
>> the return type of the current function.
>>
>> The aim is=20
>> (1) to define a local variable, which will be used to return the value o=
f=20
>> the function.
>> (2) to convert an expression to the value of the return type.
>>
>> In practice, it is convenient to use when you want to change the return=
=20
>> type without restructuring the whole function body.
>>
>> struct Type2 { explicit Type2(int){} };
>>
>> Type2 f2_braces()=20
>> {
>>     returntype local2{2}; // ok
>>     return local2; //
>>
>>     ...
>>     return returntype{10}; // ok
>> }
>>
>> If I want to change Type2 to Type3 I need only to change the function=20
>> header without touching the body.
>>
>>
>>
>>

--=20

---=20
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 e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposa=
ls/.

------=_Part_6784_799715845.1443495681564
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">Could someone who&#39;s in favor of this idea post an exam=
ple of actual code (from an actual codebase) where this shortcut would be u=
seful? In my opinion, all the examples thus far have either<div>- used simp=
le typedefs like &quot;Type2&quot; or &quot;SomeType&quot; which are no tro=
uble at all to repeat, or</div><div>- been amenable to a simple &quot;retur=
n { initializer };&quot; without any local variable declaration at all, or<=
/div><div>- been amenable to using &quot;auto&quot; return type deduction t=
o eliminate the repetition, or</div><div>- some combination of the above.</=
div><div><br></div><div>In other words, the cost of this feature is high; c=
an someone show that the potential benefit is equally high?<br><br>Also =E2=
=80=94 this isn&#39;t a killer, but =E2=80=94 it seems awkward to have <b>b=
oth</b> &quot;parse the body of the function to deduce the auto return type=
&quot; <b>and</b> &quot;while parsing the body of a function, replace declt=
ype(return) with the return type of the function&quot; in the same language=
..</div><div><br></div><div>If the compiler mechanisms were available to imp=
lement this feature, I&#39;d suggest going the whole way and providing acce=
ss to &quot;the current function&quot;, something kind of like <a href=3D"h=
ttps://duckduckgo.com/?q=3D%22letrec%22">letrec</a>, or like <b>__func__</b=
> except without the quotation marks around it. This would let us implement=
 things like</div><div><br></div><div>=C2=A0 =C2=A0 auto fact =3D [](int x)=
 { return x &gt; 1 ? x * __curfunc__(x) : 1; };</div><div><br></div><div>an=
d would make <b>decltype(return)</b>=C2=A0exactly equivalent to <b>std::fun=
ction&lt;decltype(__cur_func__)&gt;::result_type</b>.</div><div><br></div><=
div>=E2=80=93Arthur=C2=A0</div><div><br>On Monday, September 28, 2015 at 6:=
01:57 AM UTC-7, Vincent Picaud wrote:<blockquote class=3D"gmail_quote" styl=
e=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left:=
 1ex;"><div dir=3D"ltr">I do agree with <span><span style=3D"color:rgb(34,3=
4,34)">Mikhail Semenov</span></span>, a<b> returntype</b> keyword would be =
nice<br><br>Note that:<br>SomeType foo(SomeArgTypes... someArgs)<br>{<br>de=
cltype(foo(someArgs)) toReturn;<br>....<br>return toReturn;<br>}<br><br>is =
only a partial and error prone solution, as you have to modify &quot;SomeAr=
gs&quot; two times:<br>=C2=A0- function prototype<br>=C2=A0- decltype(...)<=
br>if you have to modify foo arguments.<br><br>Le mercredi 23 septembre 201=
5 21:32:48 UTC+2, Mikhail Semenov a =C3=A9crit=C2=A0:<blockquote class=3D"g=
mail_quote" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;=
padding-left:1ex"><div dir=3D"ltr"><div>I propose to introduce the <b>retur=
ntype </b>keyword, which will represent the return type of the current func=
tion.</div><div><br></div><div>The aim is </div><div>(1) to define a local =
variable, which will be used to return the value of the function.</div><div=
>(2) to convert an expression to the value of the return type.</div><div><b=
r></div><div>In practice, it is convenient to use when you want to change t=
he return type without restructuring the whole function body.</div><div><br=
></div><div>struct Type2 { explicit Type2(int){} };<br></div><div><br></div=
><div>Type2 f2_braces() <br>{<br>=C2=A0=C2=A0=C2=A0 returntype local2{2}; /=
/ ok</div><div>=C2=A0=C2=A0=C2=A0 return local2; //</div><div><br></div><di=
v>=C2=A0=C2=A0=C2=A0 ...<br>=C2=A0=C2=A0=C2=A0 return returntype{10}; // ok=
<br>}</div><div><br></div><div>If I want to change Type2 to Type3 I need on=
ly to change the function header without touching the body.</div><div><br><=
/div><div><br></div><div><br></div></div></blockquote></div></blockquote></=
div></div>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

------=_Part_6784_799715845.1443495681564--
------=_Part_6783_1396604305.1443495681557--

.

------=_Part_2584_549125083.1443499278472
Content-Type: multipart/alternative;
 boundary="----=_Part_2585_1296903625.1443499278472"

------=_Part_2585_1296903625.1443499278472
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

On Monday, September 28, 2015 at 11:01:21 PM UTC-4, Arthur O'Dwyer wrote:
>
> Could someone who's in favor of this idea post an example of actual code=
=20
> (from an actual codebase) where this shortcut would be useful? In my=20
> opinion, all the examples thus far have either
> - used simple typedefs like "Type2" or "SomeType" which are no trouble at=
=20
> all to repeat
>

The trouble is not necessarily the difficulty of repeating the name. The=20
trouble is what happens when you want to *change* it. That has to be done=
=20
in two places. And that's bad; repeating the same information in two places=
=20
is just a bug waiting to happen.

That's like 80% of the point of automatic return type deduction.

, or
> - been amenable to a simple "return { initializer };" without any local=
=20
> variable declaration at all
>

Except that `return {initializer}` only works if the type is implicitly=20
convertible to that initializer. And people have a tendency to mark=20
constructors explicit just to stop people from doing that.

Not to mention the constructors you *can't* access via `{}` at all.
=20

> , or
> - been amenable to using "auto" return type deduction to eliminate the=20
> repetition
>

Which cannot always be used. Remember: `auto` only works if you put the=20
definition in a header file (or the same source file where it is used). If=
=20
you can't, and there are plenty of reasons why that'd be the case, `auto`=
=20
can't help you.
=20

> , or
> - some combination of the above.
>
> In other words, the cost of this feature is high;
>

No, the cost of this feature is actually quite low. As others have pointed=
=20
out, you could spell it `decltype(return)`, so you don't have the cost of=
=20
an actual keyword.

Even in implementation time, I can't imagine that this feature would=20
require much effort on the part of compiler writers.
=20

> can someone show that the potential benefit is equally high?
>
> Also =E2=80=94 this isn't a killer, but =E2=80=94 it seems awkward to hav=
e *both* "parse=20
> the body of the function to deduce the auto return type" *and* "while=20
> parsing the body of a function, replace decltype(return) with the return=
=20
> type of the function" in the same language.
>

Yes, that does seem odd. However, it is an unfortunate consequence of not=
=20
being able to always use the former.

Maybe once we get modules, we won't have to care so much about=20
header/source/etc. But until then, we do the best with what we can.

If the compiler mechanisms were available to implement this feature, I'd=20
> suggest going the whole way and providing access to "the current function=
",=20
> something kind of like letrec <https://duckduckgo.com/?q=3D%22letrec%22>,=
=20
> or like *__func__* except without the quotation marks around it. This=20
> would let us implement things like
>
>     auto fact =3D [](int x) { return x > 1 ? x * __curfunc__(x) : 1; };
>

I'm not sure why infinite loops are something worth implementing ;)

This also made me realize that, outside of TMP or constexpr shenanigans, I=
=20
don't remember the last time I used direct "call myself"-style recursion.=
=20
Oh, I've written code that would eventually call the same function. But=20
there would usually be a couple of objects between them, and it would=20
always be called on a different object instance.

So I'm not sure how useful that would be in the wild.
=20

>
> and would make *decltype(return)* exactly equivalent to=20
> *std::function<decltype(__cur_func__)>::result_type*.
>

Yes. And it'd be 3 times as long. And require including `std::function`,=20
for no adequately explained reason.

--=20

---=20
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 e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposa=
ls/.

------=_Part_2585_1296903625.1443499278472
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">On Monday, September 28, 2015 at 11:01:21 PM UTC-4, Arthur=
 O&#39;Dwyer wrote:<blockquote class=3D"gmail_quote" style=3D"margin: 0;mar=
gin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D=
"ltr">Could someone who&#39;s in favor of this idea post an example of actu=
al code (from an actual codebase) where this shortcut would be useful? In m=
y opinion, all the examples thus far have either<div>- used simple typedefs=
 like &quot;Type2&quot; or &quot;SomeType&quot; which are no trouble at all=
 to repeat</div></div></blockquote><div><br>The trouble is not necessarily =
the difficulty of repeating the name. The trouble is what happens when you =
want to <i>change</i> it. That has to be done in two places. And that&#39;s=
 bad; repeating the same information in two places is just a bug waiting to=
 happen.<br><br>That&#39;s like 80% of the point of automatic return type d=
eduction.<br><br></div><blockquote class=3D"gmail_quote" style=3D"margin: 0=
;margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div di=
r=3D"ltr"><div>, or</div><div>- been amenable to a simple &quot;return { in=
itializer };&quot; without any local variable declaration at all</div></div=
></blockquote><div><br>Except that `return {initializer}` only works if the=
 type is implicitly convertible to that initializer. And people have a tend=
ency to mark constructors explicit just to stop people from doing that.<br>=
<br>Not to mention the constructors you <i>can&#39;t</i> access via `{}` at=
 all.<br>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin: 0;m=
argin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=
=3D"ltr"><div>, or</div><div>- been amenable to using &quot;auto&quot; retu=
rn type deduction to eliminate the repetition</div></div></blockquote><div>=
<br>Which cannot always be used. Remember: `auto` only works if you put the=
 definition in a header file (or the same source file where it is used). If=
 you can&#39;t, and there are plenty of reasons why that&#39;d be the case,=
 `auto` can&#39;t help you.<br>=C2=A0</div><blockquote class=3D"gmail_quote=
" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;padding=
-left: 1ex;"><div dir=3D"ltr"><div>, or</div><div>- some combination of the=
 above.</div><div><br></div><div>In other words, the cost of this feature i=
s high;</div></div></blockquote><div><br>No, the cost of this feature is ac=
tually quite low. As others have pointed out, you could spell it `decltype(=
return)`, so you don&#39;t have the cost of an actual keyword.<br><br>Even =
in implementation time, I can&#39;t imagine that this feature would require=
 much effort on the part of compiler writers.<br>=C2=A0</div><blockquote cl=
ass=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px =
#ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><div> can someone show that=
 the potential benefit is equally high?<br><br>Also =E2=80=94 this isn&#39;=
t a killer, but =E2=80=94 it seems awkward to have <b>both</b> &quot;parse =
the body of the function to deduce the auto return type&quot; <b>and</b> &q=
uot;while parsing the body of a function, replace decltype(return) with the=
 return type of the function&quot; in the same language.</div></div></block=
quote><div><br>Yes, that does seem odd. However, it is an unfortunate conse=
quence of not being able to always use the former.<br><br>Maybe once we get=
 modules, we won&#39;t have to care so much about header/source/etc. But un=
til then, we do the best with what we can.<br><br></div><blockquote class=
=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #cc=
c solid;padding-left: 1ex;"><div dir=3D"ltr"><div>If the compiler mechanism=
s were available to implement this feature, I&#39;d suggest going the whole=
 way and providing access to &quot;the current function&quot;, something ki=
nd of like <a href=3D"https://duckduckgo.com/?q=3D%22letrec%22" target=3D"_=
blank" rel=3D"nofollow" onmousedown=3D"this.href=3D&#39;https://www.google.=
com/url?q\75https%3A%2F%2Fduckduckgo.com%2F%3Fq%3D%2522letrec%2522\46sa\75D=
\46sntz\0751\46usg\75AFQjCNG0GwZNriAP3sYNNF5O-uMN3rqrVw&#39;;return true;" =
onclick=3D"this.href=3D&#39;https://www.google.com/url?q\75https%3A%2F%2Fdu=
ckduckgo.com%2F%3Fq%3D%2522letrec%2522\46sa\75D\46sntz\0751\46usg\75AFQjCNG=
0GwZNriAP3sYNNF5O-uMN3rqrVw&#39;;return true;">letrec</a>, or like <b>__fun=
c__</b> except without the quotation marks around it. This would let us imp=
lement things like</div><div><br></div><div>=C2=A0 =C2=A0 auto fact =3D [](=
int x) { return x &gt; 1 ? x * __curfunc__(x) : 1; };</div></div></blockquo=
te><div><br>I&#39;m not sure why infinite loops are something worth impleme=
nting ;)<br><br>This also made me realize that, outside of TMP or constexpr=
 shenanigans, I don&#39;t remember the last time I used direct &quot;call m=
yself&quot;-style recursion. Oh, I&#39;ve written code that would eventuall=
y call the same function. But there would usually be a couple of objects be=
tween them, and it would always be called on a different object instance.<b=
r><br>So I&#39;m not sure how useful that would be in the wild.<br>=C2=A0</=
div><blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex=
;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><div><br>=
</div><div>and would make <b>decltype(return)</b>=C2=A0exactly equivalent t=
o <b>std::function&lt;decltype(__cur_<wbr>func__)&gt;::result_type</b>.</di=
v></div></blockquote><div><br>Yes. And it&#39;d be 3 times as long. And req=
uire including `std::function`, for no adequately explained reason.<br></di=
v></div>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

------=_Part_2585_1296903625.1443499278472--
------=_Part_2584_549125083.1443499278472--

.

--Apple-Mail=_BBFD7A9F-AE3C-42A1-8116-06BA64095751
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain; charset=UTF-8


> On 2015=E2=80=9309=E2=80=9324, at 10:17 PM, Mikhail Semenov <mikhailsemen=
ov1957@gmail.com> wrote:
>=20
> You either have one or the other: the type of the function is either defi=
ned (and you can use decltype(return)) or  deduced (you cannot use decltype=
(return)).

Return type deduction happens at the first return statement; subsequent one=
s have to agree with it.

I think decltype(return) should work the same as any other use of the curre=
nt function return type.

auto try_something( auto const & obj ) {
    if ( obj ) return obj.something();
    else return decltype(return) {}; // default value
}

--=20

---=20
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 e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposa=
ls/.

--Apple-Mail=_BBFD7A9F-AE3C-42A1-8116-06BA64095751
Content-Transfer-Encoding: quoted-printable
Content-Type: text/html; charset=UTF-8

<html><head><meta http-equiv=3D"Content-Type" content=3D"text/html charset=
=3Dutf-8"></head><body style=3D"word-wrap: break-word; -webkit-nbsp-mode: s=
pace; -webkit-line-break: after-white-space;" class=3D""><br class=3D""><di=
v><blockquote type=3D"cite" class=3D""><div class=3D"">On 2015=E2=80=9309=
=E2=80=9324, at 10:17 PM, Mikhail Semenov &lt;<a href=3D"mailto:mikhailseme=
nov1957@gmail.com" class=3D"">mikhailsemenov1957@gmail.com</a>&gt; wrote:</=
div><br class=3D"Apple-interchange-newline"><div class=3D""><div dir=3D"ltr=
" class=3D""><div class=3D"">You either have one or the other: the type of =
the function is either defined (and you can use decltype(return)) or&nbsp; =
deduced (you cannot use decltype(return)).</div></div></div></blockquote><d=
iv><br class=3D""></div><div>Return type deduction happens at the first <fo=
nt face=3D"Courier" class=3D"">return</font> statement; subsequent ones hav=
e to agree with it.</div><div><br class=3D""></div><div>I think <font face=
=3D"Courier" class=3D"">decltype(return)</font> should work the same as any=
 other use of the current function return type.</div><div><br class=3D""></=
div></div><div class=3D""><font face=3D"Courier" class=3D"">auto try_someth=
ing( auto const &amp; obj ) {</font></div><div class=3D""><font face=3D"Cou=
rier" class=3D"">&nbsp; &nbsp; if ( obj ) return obj.something();</font></d=
iv><div class=3D""><font face=3D"Courier" class=3D"">&nbsp; &nbsp; else ret=
urn decltype(return) {}; // default value</font></div><div class=3D""><font=
 face=3D"Courier" class=3D"">}</font></div><div class=3D""><br class=3D""><=
/div></body></html>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

--Apple-Mail=_BBFD7A9F-AE3C-42A1-8116-06BA64095751--

.

On 2015-09-29 00:01, Nicol Bolas wrote:
> On Monday, September 28, 2015 at 11:01:21 PM UTC-4, Arthur O'Dwyer wrote:
>> In other words, the cost of this feature is high;
>=20
> No, the cost of this feature is actually quite low. As others have pointe=
d=20
> out, you could spell it `decltype(return)`, so you don't have the cost of=
=20
> an actual keyword.
>=20
> Even in implementation time, I can't imagine that this feature would=20
> require much effort on the part of compiler writers.

....*if* it's an error to use it before the return type is known. Not
that I consider that as a problem; just being pedantic :-).

>> Also =E2=80=94 this isn't a killer, but =E2=80=94 it seems awkward to ha=
ve *both* "parse=20
>> the body of the function to deduce the auto return type" *and* "while=20
>> parsing the body of a function, replace decltype(return) with the return=
=20
>> type of the function" in the same language.

The example where the type is not known but is early deduced is
interesting in that respect; it's conceivable that you would indeed want
to use both features in the same function.

> This also made me realize that, outside of TMP or constexpr shenanigans, =
I=20
> don't remember the last time I used direct "call myself"-style recursion.=
=20

....quicksort? ;-) (I don't mean that you personally have written a
quicksort recently, just that there *are* reasonable cases for functions
that call themselves.)

Actually, I just wrote one the other day that checks for a certain error
initially and resorts to a default behavior in such case. Later, other
operations that fail can self-call with intentionally bad arguments to
get back to the default-behavior case. Sure, I could structured it
differently to avoid that (or use goto)... just saying, it's one case I
actually have - recently - written a function that directly calls itself.

I could imagine in the case of functions with a trampoline header that
being able to name itself would be useful. (Meaning, for example, a
function that, at the start of execution and based on some condition,
either modifies its arguments and reinvokes itself, or schedules itself
to be called again at a later time or in a different context, and then
(usually) immediately exits without doing anything further. This is a
fairly common pattern in some multi-threaded designs.)

--=20
Matthew

--=20

---=20
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 e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposa=
ls/.

.

------=_Part_5362_1707406437.1444727326041
Content-Type: multipart/alternative;
 boundary="----=_Part_5363_1894422573.1444727326041"

------=_Part_5363_1894422573.1444727326041
Content-Type: text/plain; charset=UTF-8

I think this is no more than convenience and will yield a huge amout of
problems. There are basicly two possibilities:

1. You know the return type.
--> Then it's convenience, just write using return_type = thingy; at the
beginning. That is, there is not a huge amount of merit for this addition,
except for skipping one repetition of code.

2. You don't know the return type.

In this case it seems useful and works as David pointed out. If you now
want to use decltype(return) after the first return it is basically like in
case (1.), you alread know the type and had a chance to deduce it.

So let's consider the only case where it's an addition, using
decltype(return) before the first return in a auto function.
What happens here?

decltype(return) some_value;
return &some_value;

Now this is obviously utter nonsense, but a situation were the return type
actually depends on the decltype(return) is rather likely with this sort of
programming.

Btw. if you do that in gcc

auto f()
{
decltype(f()) x;
return &x;
};

it gives exactly the error Matthew said it would

error: use of 'auto f()' before deduction of 'auto'



Hence: I don't see the point, besides removing quite managable duplicates.

But I would be interested if there is any other usage than convenience that
I am missing.

--

---
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 http://groups.google.com/a/isocpp.org/group/std-proposals/.

------=_Part_5363_1894422573.1444727326041
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">I think this is no more than convenience and will yield a =
huge amout of problems. There are basicly two possibilities:<div><br></div>=
<div>1. You know the return type.</div><div>--&gt; Then it&#39;s convenienc=
e, just write using return_type =3D thingy; at the beginning. That is, ther=
e is not a huge amount of merit for this addition, except for skipping one =
repetition of code.</div><div><br></div><div>2. You don&#39;t know the retu=
rn type.</div><div><br></div><div>In this case it seems useful and works as=
 David pointed out. If you now want to use decltype(return) after the first=
 return it is basically like in case (1.), you alread know the type and had=
 a chance to deduce it.=C2=A0</div><div><br></div><div>So let&#39;s conside=
r the only case where it&#39;s an addition, using decltype(return) before t=
he first return in a auto function.=C2=A0</div><div>What happens here?</div=
><div><br></div><div><div class=3D"prettyprint" style=3D"border: 1px solid =
rgb(187, 187, 187); word-wrap: break-word; background-color: rgb(250, 250, =
250);"><code class=3D"prettyprint"><div class=3D"subprettyprint"><span styl=
e=3D"color: #008;" class=3D"styled-by-prettify">decltype</span><span style=
=3D"color: #660;" class=3D"styled-by-prettify">(</span><span style=3D"color=
: #008;" class=3D"styled-by-prettify">return</span><span style=3D"color: #6=
60;" class=3D"styled-by-prettify">)</span><span style=3D"color: #000;" clas=
s=3D"styled-by-prettify"> some_value</span><span style=3D"color: #660;" cla=
ss=3D"styled-by-prettify">;</span><span style=3D"color: #000;" class=3D"sty=
led-by-prettify"><br></span><span style=3D"color: #008;" class=3D"styled-by=
-prettify">return</span><span style=3D"color: #000;" class=3D"styled-by-pre=
ttify"> </span><span style=3D"color: #660;" class=3D"styled-by-prettify">&a=
mp;</span><span style=3D"color: #000;" class=3D"styled-by-prettify">some_va=
lue</span><span style=3D"color: #660;" class=3D"styled-by-prettify">;</span=
><font color=3D"#666600"></font></div></code></div><div><br></div>Now this =
is obviously utter nonsense, but a situation were the return type actually =
depends on the decltype(return) is rather likely with this sort of programm=
ing.</div><div><br></div><div>Btw. if you do that in gcc</div><div><br></di=
v><div><div class=3D"prettyprint" style=3D"border: 1px solid rgb(187, 187, =
187); word-wrap: break-word; background-color: rgb(250, 250, 250);"><code c=
lass=3D"prettyprint"><div class=3D"subprettyprint"><div class=3D"subprettyp=
rint">auto f()</div><div class=3D"subprettyprint">{</div><div class=3D"subp=
rettyprint"><span class=3D"Apple-tab-span" style=3D"white-space:pre"> </spa=
n>decltype(f()) x;</div><div class=3D"subprettyprint"><span class=3D"Apple-=
tab-span" style=3D"white-space:pre"> </span>return &amp;x;</div><div class=
=3D"subprettyprint"><span style=3D"font-family: Arial, Helvetica, sans-seri=
f;">};</span><br></div></div></code></div><br>it gives exactly the error Ma=
tthew said it would</div><div><br></div><div><div class=3D"prettyprint" sty=
le=3D"border: 1px solid rgb(187, 187, 187); word-wrap: break-word; backgrou=
nd-color: rgb(250, 250, 250);"><code class=3D"prettyprint"><div class=3D"su=
bprettyprint"><pre class=3D"" style=3D"font-family: Monaco, Menlo, Consolas=
, &#39;Courier New&#39;, monospace; color: rgb(51, 51, 51); border-radius: =
4px; line-height: 20px; word-break: break-all; word-wrap: break-word; white=
-space: pre-wrap; tab-size: 4; background-color: white !important;">error: =
use of &#39;auto f()&#39; before deduction of &#39;auto&#39;</pre></div></c=
ode></div><br><br></div><div>Hence: I don&#39;t see the point, besides remo=
ving quite managable duplicates.</div><div><br></div><div>But I would be in=
terested if there is any other usage than convenience that I am missing.<br=
><br></div></div>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

------=_Part_5363_1894422573.1444727326041--
------=_Part_5362_1707406437.1444727326041--

.

--Apple-Mail=_5C936C5C-D7C5-4ADA-9ECB-7DD61A07ED9B
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain; charset=UTF-8


> On 2015=E2=80=9310=E2=80=9313, at 5:08 PM, Klemens Morgenstern <klemens.m=
orgenstern@gmx.net> wrote:
>=20
> decltype(return) some_value;
> return &some_value;

What=E2=80=99s the problem? There=E2=80=99s already a diagnosable rule for =
mismatched return expressions in a deduced function.

> Now this is obviously utter nonsense, but a situation were the return typ=
e actually depends on the decltype(return) is rather likely with this sort =
of programming.


The error is easier to avoid, not easier to commit, if the deduced return t=
ype is available to the programmer.

--=20

---=20
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 e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposa=
ls/.

--Apple-Mail=_5C936C5C-D7C5-4ADA-9ECB-7DD61A07ED9B
Content-Transfer-Encoding: quoted-printable
Content-Type: text/html; charset=UTF-8

<html><head><meta http-equiv=3D"Content-Type" content=3D"text/html charset=
=3Dutf-8"></head><body style=3D"word-wrap: break-word; -webkit-nbsp-mode: s=
pace; -webkit-line-break: after-white-space;" class=3D""><br class=3D""><di=
v><blockquote type=3D"cite" class=3D""><div class=3D"">On 2015=E2=80=9310=
=E2=80=9313, at 5:08 PM, Klemens Morgenstern &lt;<a href=3D"mailto:klemens.=
morgenstern@gmx.net" class=3D"">klemens.morgenstern@gmx.net</a>&gt; wrote:<=
/div><br class=3D"Apple-interchange-newline"><div class=3D""><div style=3D"=
font-family: Helvetica; font-size: 12px; font-style: normal; font-variant: =
normal; font-weight: normal; letter-spacing: normal; line-height: normal; o=
rphans: auto; text-align: start; text-indent: 0px; text-transform: none; wh=
ite-space: normal; widows: auto; word-spacing: 0px; -webkit-text-stroke-wid=
th: 0px;" class=3D""><div class=3D"prettyprint" style=3D"border: 1px solid =
rgb(187, 187, 187); word-wrap: break-word; background-color: rgb(250, 250, =
250);"><code class=3D"prettyprint"><span class=3D"styled-by-prettify" style=
=3D"color: rgb(0, 0, 136);">decltype</span><span class=3D"styled-by-prettif=
y" style=3D"color: rgb(102, 102, 0);">(</span><span class=3D"styled-by-pret=
tify" style=3D"color: rgb(0, 0, 136);">return</span><span class=3D"styled-b=
y-prettify" style=3D"color: rgb(102, 102, 0);">)</span><span class=3D"Apple=
-converted-space">&nbsp;</span>some_value<span class=3D"styled-by-prettify"=
 style=3D"color: rgb(102, 102, 0);">;</span><br class=3D""><span class=3D"s=
tyled-by-prettify" style=3D"color: rgb(0, 0, 136);">return</span>&nbsp;<spa=
n class=3D"styled-by-prettify" style=3D"color: rgb(102, 102, 0);">&amp;</sp=
an>some_value<span class=3D"styled-by-prettify" style=3D"color: rgb(102, 10=
2, 0);">;</span><font color=3D"#666600" class=3D""></font></code></div><div=
 class=3D""></div></div></div></blockquote><div><br class=3D""></div><div c=
lass=3D"">What=E2=80=99s the problem? There=E2=80=99s already a diagnosable=
 rule for mismatched return expressions in a deduced function.</div><div cl=
ass=3D""><br class=3D""></div><blockquote type=3D"cite" class=3D""><div cla=
ss=3D""><div style=3D"font-family: Helvetica; font-size: 12px; font-style: =
normal; font-variant: normal; font-weight: normal; letter-spacing: normal; =
line-height: normal; orphans: auto; text-align: start; text-indent: 0px; te=
xt-transform: none; white-space: normal; widows: auto; word-spacing: 0px; -=
webkit-text-stroke-width: 0px;" class=3D"">Now this is obviously utter nons=
ense, but a situation were the return type actually depends on the decltype=
(return) is rather likely with this sort of programming.</div></div></block=
quote></div><div class=3D""><br class=3D""></div><div class=3D"">The error =
is easier to <i class=3D"">avoid</i>, not easier to commit, if the deduced =
return type is available to the programmer.</div><div class=3D""><br class=
=3D""></div></body></html>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

--Apple-Mail=_5C936C5C-D7C5-4ADA-9ECB-7DD61A07ED9B--

.

------=_Part_5591_543897153.1444728658159
Content-Type: multipart/alternative;
 boundary="----=_Part_5592_347655381.1444728658167"

------=_Part_5592_347655381.1444728658167
Content-Type: text/plain; charset=UTF-8

So decltype(return) would be the same as decltype(foo()) ? That would mean
to me, that there's already a similar thing, so it's not necessary. Or it
behaves differently, in which case it could be overly complicated and I
didn't see the rules.

--

---
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 http://groups.google.com/a/isocpp.org/group/std-proposals/.

------=_Part_5592_347655381.1444728658167
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">So decltype(return) would be the same as decltype(foo()) ?=
 That would mean to me, that there&#39;s already a similar thing, so it&#39=
;s not necessary. Or it behaves differently, in which case it could be over=
ly complicated and I didn&#39;t see the rules.</div>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

------=_Part_5592_347655381.1444728658167--
------=_Part_5591_543897153.1444728658159--

.

--Apple-Mail=_4477C5A2-52A8-49C9-B50C-CA8DC8394859
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain; charset=UTF-8


> On 2015=E2=80=9310=E2=80=9313, at 5:30 PM, Klemens Morgenstern <klemens.m=
orgenstern@gmx.net> wrote:
>=20
> So decltype(return) would be the same as decltype(foo()) ? That would mea=
n to me, that there's already a similar thing, so it's not necessary.

For functions with parameters, the call expression is not as simple as foo(=
).

--=20

---=20
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 e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposa=
ls/.

--Apple-Mail=_4477C5A2-52A8-49C9-B50C-CA8DC8394859
Content-Transfer-Encoding: quoted-printable
Content-Type: text/html; charset=UTF-8

<html><head><meta http-equiv=3D"Content-Type" content=3D"text/html charset=
=3Dutf-8"></head><body style=3D"word-wrap: break-word; -webkit-nbsp-mode: s=
pace; -webkit-line-break: after-white-space;" class=3D""><br class=3D""><di=
v><blockquote type=3D"cite" class=3D""><div class=3D"">On 2015=E2=80=9310=
=E2=80=9313, at 5:30 PM, Klemens Morgenstern &lt;<a href=3D"mailto:klemens.=
morgenstern@gmx.net" class=3D"">klemens.morgenstern@gmx.net</a>&gt; wrote:<=
/div><br class=3D"Apple-interchange-newline"><div class=3D""><div dir=3D"lt=
r" class=3D"">So decltype(return) would be the same as decltype(foo()) ? Th=
at would mean to me, that there's already a similar thing, so it's not nece=
ssary.</div></div></blockquote><div><br class=3D""></div><div>For functions=
 with parameters, the call expression is not as simple as <font face=3D"Cou=
rier" class=3D"">foo()</font>.</div></div><br class=3D""></body></html>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

--Apple-Mail=_4477C5A2-52A8-49C9-B50C-CA8DC8394859--

.

--e89a8f2350158105560521f96e9f
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

On 13 October 2015 at 10:51, David Krauss <potswa@gmail.com> wrote:

>
> On 2015=E2=80=9310=E2=80=9313, at 5:30 PM, Klemens Morgenstern <
> klemens.morgenstern@gmx.net> wrote:
>
> So decltype(return) would be the same as decltype(foo()) ? That would mea=
n
> to me, that there's already a similar thing, so it's not necessary.
>
>
> For functions with parameters, the call expression is not as simple as
> foo().
>

plus it's duplication which is what this is trying to avoid. what if i want
to rename foo? or change it's parameters. decltype(return) will also work.

--=20

---=20
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 e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposa=
ls/.

--e89a8f2350158105560521f96e9f
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><br><div class=3D"gmail_extra"><br><div class=3D"gmail_quo=
te">On 13 October 2015 at 10:51, David Krauss <span dir=3D"ltr">&lt;<a href=
=3D"mailto:potswa@gmail.com" target=3D"_blank">potswa@gmail.com</a>&gt;</sp=
an> wrote:<br><blockquote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;=
border-left:1px #ccc solid;padding-left:1ex"><div style=3D"word-wrap:break-=
word"><br><div><span class=3D""><blockquote type=3D"cite"><div>On 2015=E2=
=80=9310=E2=80=9313, at 5:30 PM, Klemens Morgenstern &lt;<a href=3D"mailto:=
klemens.morgenstern@gmx.net" target=3D"_blank">klemens.morgenstern@gmx.net<=
/a>&gt; wrote:</div><br><div><div dir=3D"ltr">So decltype(return) would be =
the same as decltype(foo()) ? That would mean to me, that there&#39;s alrea=
dy a similar thing, so it&#39;s not necessary.</div></div></blockquote><div=
><br></div></span><div>For functions with parameters, the call expression i=
s not as simple as <font face=3D"Courier">foo()</font>.</div></div></div></=
blockquote><div><br></div><div>plus it&#39;s duplication which is what this=
 is trying to avoid. what if i want to rename foo? or change it&#39;s param=
eters. decltype(return) will also work.<br></div></div></div></div>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

--e89a8f2350158105560521f96e9f--

.

------=_Part_111_1700992106.1444731261093
Content-Type: multipart/alternative;
 boundary="----=_Part_112_1107394813.1444731261093"

------=_Part_112_1107394813.1444731261093
Content-Type: text/plain; charset=UTF-8

Ok, well then it's still convenience but is has already defined behaviour.
Though that convenience might indead lead to safer code, since it motivates
to use type_traits or static_assert on the return type.

--

---
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 http://groups.google.com/a/isocpp.org/group/std-proposals/.

------=_Part_112_1107394813.1444731261093
Content-Type: text/html; charset=UTF-8

<div dir="ltr">Ok, well then it&#39;s still convenience but is has already defined behaviour. Though that convenience might indead lead to safer code, since it motivates to use type_traits or static_assert on the return type.<div><br></div></div>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an email to <a href="mailto:std-proposals+unsubscribe@isocpp.org">std-proposals+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href="mailto:std-proposals@isocpp.org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href="http://groups.google.com/a/isocpp.org/group/std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/</a>.<br />

------=_Part_112_1107394813.1444731261093--
------=_Part_111_1700992106.1444731261093--

.

On 2015-10-13 05:08, Klemens Morgenstern wrote:
> decltype(return) some_value;
> return &some_value;
>
> Now this is obviously utter nonsense

Not necessarily; I can write a type whose operator& returns the same
type. (And I'll probably get shot if I do ;-), but that's not the point.)

Anyway, not really a problem, as already explained.

> I don't see the point, besides removing quite managable duplicates.
> But I would be interested if there is any other usage than
> convenience that I am missing.

Sam didn't put it exactly this way, but the effect is that repeating the
function signature violates DRY. And doing so could be quite obnoxious,
e.g. if you're defining functions through a macro (pretty sure I've done
things like this). Or a code generator; granted, a code generator can
probably handle generating the correct code, but it'd sure be convenient
if it didn't need to do so.

Basically, there are various reasons why repeating the function
signature is less than desirable.

--
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 http://groups.google.com/a/isocpp.org/group/std-proposals/.

.

------=_Part_6546_2123235788.1444799018826
Content-Type: multipart/alternative;
 boundary="----=_Part_6547_1849780708.1444799018827"

------=_Part_6547_1849780708.1444799018827
Content-Type: text/plain; charset=UTF-8


>
> Basically, there are various reasons why repeating the function
> signature is less than desirable.
>

Well I am doubting that this is convincing, however there might be
situations where you need it for ambiguity reasons:


double foo(const bar & f)
{
      return 34.1;
}


int foo(bar && b)
{
        decltype(foo(b)) x; //type == double, because b binds to const bar
&  inside the function
        decltype(return) y; //type == int
        return 42;
}


But I can't really come up with a good example where this is needed. Maybe
someone else has an idea.

--

---
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 http://groups.google.com/a/isocpp.org/group/std-proposals/.

------=_Part_6547_1849780708.1444799018827
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><blockquote class=3D"gmail_quote" style=3D"margin: 0;margi=
n-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;">Basically, th=
ere are various reasons why repeating the function
<br>signature is less than desirable.
<br></blockquote><div><br></div><div>Well I am doubting that this is convin=
cing, however there might be situations where you need it for ambiguity rea=
sons:</div><div><br></div><div><br></div><div><div class=3D"prettyprint" st=
yle=3D"border: 1px solid rgb(187, 187, 187); word-wrap: break-word; backgro=
und-color: rgb(250, 250, 250);"><code class=3D"prettyprint"><div class=3D"s=
ubprettyprint"><span style=3D"color: #008;" class=3D"styled-by-prettify">do=
uble</span><span style=3D"color: #000;" class=3D"styled-by-prettify"> foo</=
span><span style=3D"color: #660;" class=3D"styled-by-prettify">(</span><spa=
n style=3D"color: #008;" class=3D"styled-by-prettify">const</span><span sty=
le=3D"color: #000;" class=3D"styled-by-prettify"> bar </span><span style=3D=
"color: #660;" class=3D"styled-by-prettify">&amp;</span><span style=3D"colo=
r: #000;" class=3D"styled-by-prettify"> f</span><span style=3D"color: #660;=
" class=3D"styled-by-prettify">)</span><span style=3D"color: #000;" class=
=3D"styled-by-prettify"><br></span><span style=3D"color: #660;" class=3D"st=
yled-by-prettify">{</span><span style=3D"color: #000;" class=3D"styled-by-p=
rettify"><br>=C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color: #008;" class=
=3D"styled-by-prettify">return</span><span style=3D"color: #000;" class=3D"=
styled-by-prettify"> </span><span style=3D"color: #066;" class=3D"styled-by=
-prettify">34.1</span><span style=3D"color: #660;" class=3D"styled-by-prett=
ify">;</span><span style=3D"color: #000;" class=3D"styled-by-prettify"><br>=
</span><span style=3D"color: #660;" class=3D"styled-by-prettify">}</span><s=
pan style=3D"color: #000;" class=3D"styled-by-prettify"><br><br><br></span>=
<span style=3D"color: #008;" class=3D"styled-by-prettify">int</span><span s=
tyle=3D"color: #000;" class=3D"styled-by-prettify"> foo</span><span style=
=3D"color: #660;" class=3D"styled-by-prettify">(</span><span style=3D"color=
: #000;" class=3D"styled-by-prettify">bar </span><span style=3D"color: #660=
;" class=3D"styled-by-prettify">&amp;&amp;</span><span style=3D"color: #000=
;" class=3D"styled-by-prettify"> b</span><span style=3D"color: #660;" class=
=3D"styled-by-prettify">)</span><span style=3D"color: #000;" class=3D"style=
d-by-prettify"><br></span><span style=3D"color: #660;" class=3D"styled-by-p=
rettify">{</span><span style=3D"color: #000;" class=3D"styled-by-prettify">=
<br>=C2=A0 =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color: #008;" class=
=3D"styled-by-prettify">decltype</span><span style=3D"color: #660;" class=
=3D"styled-by-prettify">(</span><span style=3D"color: #000;" class=3D"style=
d-by-prettify">foo</span><span style=3D"color: #660;" class=3D"styled-by-pr=
ettify">(</span><span style=3D"color: #000;" class=3D"styled-by-prettify">b=
</span><span style=3D"color: #660;" class=3D"styled-by-prettify">))</span><=
span style=3D"color: #000;" class=3D"styled-by-prettify"> x</span><span sty=
le=3D"color: #660;" class=3D"styled-by-prettify">;</span><span style=3D"col=
or: #000;" class=3D"styled-by-prettify"> </span><span style=3D"color: #800;=
" class=3D"styled-by-prettify">//type =3D=3D double, because b binds to con=
st bar &amp; =C2=A0inside the function</span><span style=3D"color: #000;" c=
lass=3D"styled-by-prettify"><br>=C2=A0 =C2=A0 =C2=A0 =C2=A0 </span><span st=
yle=3D"color: #008;" class=3D"styled-by-prettify">decltype</span><span styl=
e=3D"color: #660;" class=3D"styled-by-prettify">(</span><span style=3D"colo=
r: #008;" class=3D"styled-by-prettify">return</span><span style=3D"color: #=
660;" class=3D"styled-by-prettify">)</span><span style=3D"color: #000;" cla=
ss=3D"styled-by-prettify"> y</span><span style=3D"color: #660;" class=3D"st=
yled-by-prettify">;</span><span style=3D"color: #000;" class=3D"styled-by-p=
rettify"> </span><span style=3D"color: #800;" class=3D"styled-by-prettify">=
//type =3D=3D int</span><span style=3D"color: #000;" class=3D"styled-by-pre=
ttify"><br>=C2=A0 =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color: #008;" =
class=3D"styled-by-prettify">return</span><span style=3D"color: #000;" clas=
s=3D"styled-by-prettify"> </span><span style=3D"color: #066;" class=3D"styl=
ed-by-prettify">42</span><span style=3D"color: #660;" class=3D"styled-by-pr=
ettify">;</span><span style=3D"color: #000;" class=3D"styled-by-prettify"><=
br></span><span style=3D"color: #660;" class=3D"styled-by-prettify">}</span=
></div></code></div><div style=3D"font-family: Arial, Helvetica, sans-serif=
; background-color: rgb(255, 255, 255);"><br></div><br>But I can&#39;t real=
ly come up with a good example where this is needed. Maybe someone else has=
 an idea.</div><div><br></div></div>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

------=_Part_6547_1849780708.1444799018827--
------=_Part_6546_2123235788.1444799018826--

.

--001a11c3bfeece019305220b7db9
Content-Type: text/plain; charset=UTF-8

On 14 October 2015 at 06:03, Klemens Morgenstern <
klemens.morgenstern@gmx.net> wrote:

> Basically, there are various reasons why repeating the function
>> signature is less than desirable.
>>
>
> Well I am doubting that this is convincing, however there might be
> situations where you need it for ambiguity reasons:
>
>
> double foo(const bar & f)
> {
>       return 34.1;
> }
>
>
> int foo(bar && b)
> {
>         decltype(foo(b)) x; //type == double, because b binds to const
> bar &  inside the function
>         decltype(return) y; //type == int
>         return 42;
> }
>
>
> But I can't really come up with a good example where this is needed. Maybe
> someone else has an idea.
>

what about when the return type is the result of some complex
metaprogramming calculation?

--

---
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 http://groups.google.com/a/isocpp.org/group/std-proposals/.

--001a11c3bfeece019305220b7db9
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><br><div class=3D"gmail_extra"><br><div class=3D"gmail_quo=
te">On 14 October 2015 at 06:03, Klemens Morgenstern <span dir=3D"ltr">&lt;=
<a href=3D"mailto:klemens.morgenstern@gmx.net" target=3D"_blank">klemens.mo=
rgenstern@gmx.net</a>&gt;</span> wrote:<br><blockquote class=3D"gmail_quote=
" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><=
div dir=3D"ltr"><span class=3D""><blockquote class=3D"gmail_quote" style=3D=
"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-left:1ex">Ba=
sically, there are various reasons why repeating the function
<br>signature is less than desirable.
<br></blockquote><div><br></div></span><div>Well I am doubting that this is=
 convincing, however there might be situations where you need it for ambigu=
ity reasons:</div><div><br></div><div><br></div><div><div style=3D"border:1=
px solid rgb(187,187,187);word-wrap:break-word;background-color:rgb(250,250=
,250)"><code><div><span style=3D"color:#008">double</span><span style=3D"co=
lor:#000"> foo</span><span style=3D"color:#660">(</span><span style=3D"colo=
r:#008">const</span><span style=3D"color:#000"> bar </span><span style=3D"c=
olor:#660">&amp;</span><span style=3D"color:#000"> f</span><span style=3D"c=
olor:#660">)</span><span style=3D"color:#000"><br></span><span style=3D"col=
or:#660">{</span><span style=3D"color:#000"><br>=C2=A0 =C2=A0 =C2=A0 </span=
><span style=3D"color:#008">return</span><span style=3D"color:#000"> </span=
><span style=3D"color:#066">34.1</span><span style=3D"color:#660">;</span><=
span style=3D"color:#000"><br></span><span style=3D"color:#660">}</span><sp=
an style=3D"color:#000"><br><br><br></span><span style=3D"color:#008">int</=
span><span style=3D"color:#000"> foo</span><span style=3D"color:#660">(</sp=
an><span style=3D"color:#000">bar </span><span style=3D"color:#660">&amp;&a=
mp;</span><span style=3D"color:#000"> b</span><span style=3D"color:#660">)<=
/span><span style=3D"color:#000"><br></span><span style=3D"color:#660">{</s=
pan><span style=3D"color:#000"><br>=C2=A0 =C2=A0 =C2=A0 =C2=A0 </span><span=
 style=3D"color:#008">decltype</span><span style=3D"color:#660">(</span><sp=
an style=3D"color:#000">foo</span><span style=3D"color:#660">(</span><span =
style=3D"color:#000">b</span><span style=3D"color:#660">))</span><span styl=
e=3D"color:#000"> x</span><span style=3D"color:#660">;</span><span style=3D=
"color:#000"> </span><span style=3D"color:#800">//type =3D=3D double, becau=
se b binds to const bar &amp; =C2=A0inside the function</span><span style=
=3D"color:#000"><br>=C2=A0 =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color=
:#008">decltype</span><span style=3D"color:#660">(</span><span style=3D"col=
or:#008">return</span><span style=3D"color:#660">)</span><span style=3D"col=
or:#000"> y</span><span style=3D"color:#660">;</span><span style=3D"color:#=
000"> </span><span style=3D"color:#800">//type =3D=3D int</span><span style=
=3D"color:#000"><br>=C2=A0 =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color=
:#008">return</span><span style=3D"color:#000"> </span><span style=3D"color=
:#066">42</span><span style=3D"color:#660">;</span><span style=3D"color:#00=
0"><br></span><span style=3D"color:#660">}</span></div></code></div><div st=
yle=3D"font-family:Arial,Helvetica,sans-serif;background-color:rgb(255,255,=
255)"><br></div><br>But I can&#39;t really come up with a good example wher=
e this is needed. Maybe someone else has an idea.</div></div></blockquote><=
div><br></div><div>what about when the return type is the result of some co=
mplex metaprogramming calculation? <br></div></div><br></div></div>

<p></p>

-- <br />
<br />
--- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
Visit this group at <a href=3D"http://groups.google.com/a/isocpp.org/group/=
std-proposals/">http://groups.google.com/a/isocpp.org/group/std-proposals/<=
/a>.<br />

--001a11c3bfeece019305220b7db9--

.