Topic: Comment/Query about N3729 std::invocation_type<T>


Author: Andrew Tomazos <andrewtomazos@gmail.com>
Date: Wed, 27 Nov 2013 20:04:58 -0800 (PST)
Raw View
------=_Part_1169_17520807.1385611498717
Content-Type: text/plain; charset=ISO-8859-1

Just a quick bikeshed comment/query about N3729
std::invocation_type http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3729.html:

> std::invocation_type<C(int, int)>::type would be int(double, int). More
precisely the return type of invocation_type<Fn(ArgTypes...)> is
result_of<Fn(ArgTypes...)> and each argument type is the same as the formal
parameter type matched in the call to Fn.

If I understand the interface correctly, the type parameter T to
std::invocation_type<T> is formed by making a function type R(P1, P2, ...,
PN) where R is the type of a family of invokable values (not a return type).

On the surface I consider this confusing because you are manufacturing an
unused function type T just to pass something in its return type which
isn't a return type.  ie T is never used, it is just unpacked.

Wouldn't the clearer interface be std::invocation_type<C, P1, P2, ..., PN>?

That is:

    namespace std
    {
        template <class Fn, class... ArgTypes>
        struct invocation_type
        {
            using type = whatever;
        };
    }

So the quoted example would instead read "std::invocation_type<C, int,
int>::type is int(double, int)"

Sorry if this was already discussed and discarded.  I'm not sure if there
are mechanical benefits to manufacturing T as a function type being
leveraged (such as being able to pass varargs and properties of a function
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_1169_17520807.1385611498717
Content-Type: text/html; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><font face=3D"arial, sans-serif" size=3D"2">Just a quick b=
ikeshed comment/query about N3729 std::invocation_type&nbsp;http://www.open=
-std.org/jtc1/sc22/wg21/docs/papers/2013/n3729.html:</font><div><font face=
=3D"arial, sans-serif" size=3D"2"><br></font></div><div><font face=3D"arial=
, sans-serif" size=3D"2">&gt;&nbsp;<tt style=3D"color: rgb(0, 0, 0);">std::=
invocation_type&lt;C(int, int)&gt;::type</tt><span style=3D"color: rgb(0, 0=
, 0);">&nbsp;would be&nbsp;</span><tt style=3D"color: rgb(0, 0, 0);">int(do=
uble, int)</tt><span style=3D"color: rgb(0, 0, 0);">. More precisely the re=
turn type of&nbsp;</span><tt style=3D"color: rgb(0, 0, 0);">invocation_type=
&lt;Fn(ArgTypes...)&gt;</tt><span style=3D"color: rgb(0, 0, 0);">&nbsp;is&n=
bsp;</span><tt style=3D"color: rgb(0, 0, 0);">result_of&lt;Fn(ArgTypes...)&=
gt;</tt><span style=3D"color: rgb(0, 0, 0);">&nbsp;and each argument type i=
s the same as the formal parameter type matched in the call to&nbsp;</span>=
<tt style=3D"color: rgb(0, 0, 0);">Fn</tt><span style=3D"color: rgb(0, 0, 0=
);">.</span><span style=3D"color: rgb(0, 0, 0);"><br></span></font></div><d=
iv><span style=3D"color: rgb(0, 0, 0);"><font face=3D"arial, sans-serif" si=
ze=3D"2"><br></font></span></div><div><font color=3D"#000000" face=3D"arial=
, sans-serif" size=3D"2">If I understand the interface correctly, the type =
parameter T to std::invocation_type&lt;T&gt; is formed by making a function=
 type R(P1, P2, ..., PN) where R is the type of a family of invokable value=
s (not a return type).</font></div><div><font color=3D"#000000" face=3D"ari=
al, sans-serif" size=3D"2"><br></font></div><div><font color=3D"#000000" fa=
ce=3D"arial, sans-serif" size=3D"2">On the surface I consider this confusin=
g because you are manufacturing an unused function type T just to pass some=
thing in its return type which isn't a return type. &nbsp;ie T is never use=
d, it is just unpacked.</font></div><div><br></div><div><font color=3D"#000=
000" face=3D"arial, sans-serif" size=3D"2">Wouldn't the clearer interface b=
e std::invocation_type&lt;C, P1, P2, ..., PN&gt;?</font></div><div><font co=
lor=3D"#000000" face=3D"arial, sans-serif" size=3D"2" style=3D"background-c=
olor: rgb(255, 255, 255);"><br></font></div><div><font color=3D"#000000" fa=
ce=3D"arial, sans-serif" size=3D"2" style=3D"background-color: rgb(255, 255=
, 255);">That is:</font></div><div><font color=3D"#000000" face=3D"arial, s=
ans-serif" size=3D"2" style=3D"background-color: rgb(255, 255, 255);"><br><=
/font></div><div><div><font face=3D"courier new, monospace"><span style=3D"=
color: rgb(0, 0, 0); font-size: small;">&nbsp; &nbsp; namespace std</span><=
br></font></div><div><font color=3D"#000000" size=3D"2" face=3D"courier new=
, monospace">&nbsp; &nbsp; {</font></div><div><font color=3D"#000000" size=
=3D"2" face=3D"courier new, monospace">&nbsp; &nbsp; &nbsp; &nbsp; template=
 &lt;class Fn, class... ArgTypes&gt;</font></div><div><font color=3D"#00000=
0" size=3D"2" face=3D"courier new, monospace">&nbsp; &nbsp; &nbsp; &nbsp; s=
truct invocation_type</font></div><div><font color=3D"#000000" size=3D"2" f=
ace=3D"courier new, monospace">&nbsp; &nbsp; &nbsp; &nbsp; {</font></div><d=
iv><font color=3D"#000000" size=3D"2" face=3D"courier new, monospace">&nbsp=
; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; using type =3D whatever;</font></div><=
div><font color=3D"#000000" size=3D"2" face=3D"courier new, monospace">&nbs=
p; &nbsp; &nbsp; &nbsp; };</font></div><div><font color=3D"#000000" size=3D=
"2" face=3D"courier new, monospace">&nbsp; &nbsp; }</font></div></div><div>=
<br></div><div>So the quoted example would instead read "std::invocation_ty=
pe&lt;C, int, int&gt;::type is int(double, int)"</div><div><br></div><div>S=
orry if this was already discussed and discarded. &nbsp;I'm not sure if the=
re are mechanical benefits to manufacturing T as a function type being leve=
raged (such as being able to pass varargs and properties of a function type=
).</div><div><br></div><div><br></div></div>

<p></p>

-- <br />
&nbsp;<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 std-proposals+unsubscribe@isocpp.org.<br />
To post to this group, send email to std-proposals@isocpp.org.<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_1169_17520807.1385611498717--

.


Author: Andrew Tomazos <andrewtomazos@gmail.com>
Date: Wed, 27 Nov 2013 20:22:17 -0800 (PST)
Raw View
------=_Part_1169_30168531.1385612537302
Content-Type: text/plain; charset=ISO-8859-1

It looks like std::result_of<T> is already using this style of interface,
and std::invocation_type inherited it, so I guess this is too late.  I
guess it's no big deal.

On Thursday, November 28, 2013 5:04:58 AM UTC+1, Andrew Tomazos wrote:
>
> Just a quick bikeshed comment/query about N3729 std::invocation_type
> http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3729.html:
>
> > std::invocation_type<C(int, int)>::type would be int(double, int). More
> precisely the return type of invocation_type<Fn(ArgTypes...)> is
> result_of<Fn(ArgTypes...)> and each argument type is the same as the
> formal parameter type matched in the call to Fn.
>
> If I understand the interface correctly, the type parameter T to
> std::invocation_type<T> is formed by making a function type R(P1, P2, ...,
> PN) where R is the type of a family of invokable values (not a return type).
>
> On the surface I consider this confusing because you are manufacturing an
> unused function type T just to pass something in its return type which
> isn't a return type.  ie T is never used, it is just unpacked.
>
> Wouldn't the clearer interface be std::invocation_type<C, P1, P2, ..., PN>?
>
> That is:
>
>     namespace std
>     {
>         template <class Fn, class... ArgTypes>
>         struct invocation_type
>         {
>             using type = whatever;
>         };
>     }
>
> So the quoted example would instead read "std::invocation_type<C, int,
> int>::type is int(double, int)"
>
> Sorry if this was already discussed and discarded.  I'm not sure if there
> are mechanical benefits to manufacturing T as a function type being
> leveraged (such as being able to pass varargs and properties of a function
> 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_1169_30168531.1385612537302
Content-Type: text/html; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">It looks like std::result_of&lt;T&gt; is already using thi=
s style of interface, and std::invocation_type inherited it, so I guess thi=
s is too late. &nbsp;I guess it's no big deal.<div><br>On Thursday, Novembe=
r 28, 2013 5:04:58 AM UTC+1, Andrew Tomazos wrote:<blockquote class=3D"gmai=
l_quote" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;=
padding-left: 1ex;"><div dir=3D"ltr"><font face=3D"arial, sans-serif" size=
=3D"2">Just a quick bikeshed comment/query about N3729 std::invocation_type=
&nbsp;<a href=3D"http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3=
729.html" target=3D"_blank" onmousedown=3D"this.href=3D'http://www.google.c=
om/url?q\75http%3A%2F%2Fwww.open-std.org%2Fjtc1%2Fsc22%2Fwg21%2Fdocs%2Fpape=
rs%2F2013%2Fn3729.html\46sa\75D\46sntz\0751\46usg\75AFQjCNHlCxaU9vODuwI0OaW=
4WQucZhH_pw';return true;" onclick=3D"this.href=3D'http://www.google.com/ur=
l?q\75http%3A%2F%2Fwww.open-std.org%2Fjtc1%2Fsc22%2Fwg21%2Fdocs%2Fpapers%2F=
2013%2Fn3729.html\46sa\75D\46sntz\0751\46usg\75AFQjCNHlCxaU9vODuwI0OaW4WQuc=
ZhH_pw';return true;">http://<wbr>www.open-std.org/jtc1/sc22/<wbr>wg21/docs=
/papers/2013/n3729.<wbr>html</a>:</font><div><font face=3D"arial, sans-seri=
f" size=3D"2"><br></font></div><div><font face=3D"arial, sans-serif" size=
=3D"2">&gt;&nbsp;<tt style=3D"color:rgb(0,0,0)">std::invocation_type&lt;C(i=
nt, int)&gt;::type</tt><span style=3D"color:rgb(0,0,0)">&nbsp;would be&nbsp=
;</span><tt style=3D"color:rgb(0,0,0)">int(double, int)</tt><span style=3D"=
color:rgb(0,0,0)">. More precisely the return type of&nbsp;</span><tt style=
=3D"color:rgb(0,0,0)">invocation_type&lt;Fn(<wbr>ArgTypes...)&gt;</tt><span=
 style=3D"color:rgb(0,0,0)">&nbsp;is&nbsp;</span><tt style=3D"color:rgb(0,0=
,0)">result_of&lt;Fn(<wbr>ArgTypes...)&gt;</tt><span style=3D"color:rgb(0,0=
,0)">&nbsp;and each argument type is the same as the formal parameter type =
matched in the call to&nbsp;</span><tt style=3D"color:rgb(0,0,0)">Fn</tt><s=
pan style=3D"color:rgb(0,0,0)">.</span><span style=3D"color:rgb(0,0,0)"><br=
></span></font></div><div><span style=3D"color:rgb(0,0,0)"><font face=3D"ar=
ial, sans-serif" size=3D"2"><br></font></span></div><div><font color=3D"#00=
0000" face=3D"arial, sans-serif" size=3D"2">If I understand the interface c=
orrectly, the type parameter T to std::invocation_type&lt;T&gt; is formed b=
y making a function type R(P1, P2, ..., PN) where R is the type of a family=
 of invokable values (not a return type).</font></div><div><font color=3D"#=
000000" face=3D"arial, sans-serif" size=3D"2"><br></font></div><div><font c=
olor=3D"#000000" face=3D"arial, sans-serif" size=3D"2">On the surface I con=
sider this confusing because you are manufacturing an unused function type =
T just to pass something in its return type which isn't a return type. &nbs=
p;ie T is never used, it is just unpacked.</font></div><div><br></div><div>=
<font color=3D"#000000" face=3D"arial, sans-serif" size=3D"2">Wouldn't the =
clearer interface be std::invocation_type&lt;C, P1, P2, ..., PN&gt;?</font>=
</div><div><font color=3D"#000000" face=3D"arial, sans-serif" size=3D"2" st=
yle=3D"background-color:rgb(255,255,255)"><br></font></div><div><font color=
=3D"#000000" face=3D"arial, sans-serif" size=3D"2" style=3D"background-colo=
r:rgb(255,255,255)">That is:</font></div><div><font color=3D"#000000" face=
=3D"arial, sans-serif" size=3D"2" style=3D"background-color:rgb(255,255,255=
)"><br></font></div><div><div><font face=3D"courier new, monospace"><span s=
tyle=3D"color:rgb(0,0,0);font-size:small">&nbsp; &nbsp; namespace std</span=
><br></font></div><div><font color=3D"#000000" size=3D"2" face=3D"courier n=
ew, monospace">&nbsp; &nbsp; {</font></div><div><font color=3D"#000000" siz=
e=3D"2" face=3D"courier new, monospace">&nbsp; &nbsp; &nbsp; &nbsp; templat=
e &lt;class Fn, class... ArgTypes&gt;</font></div><div><font color=3D"#0000=
00" size=3D"2" face=3D"courier new, monospace">&nbsp; &nbsp; &nbsp; &nbsp; =
struct invocation_type</font></div><div><font color=3D"#000000" size=3D"2" =
face=3D"courier new, monospace">&nbsp; &nbsp; &nbsp; &nbsp; {</font></div><=
div><font color=3D"#000000" size=3D"2" face=3D"courier new, monospace">&nbs=
p; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; using type =3D whatever;</font></div>=
<div><font color=3D"#000000" size=3D"2" face=3D"courier new, monospace">&nb=
sp; &nbsp; &nbsp; &nbsp; };</font></div><div><font color=3D"#000000" size=
=3D"2" face=3D"courier new, monospace">&nbsp; &nbsp; }</font></div></div><d=
iv><br></div><div>So the quoted example would instead read "std::invocation=
_type&lt;C, int, int&gt;::type is int(double, int)"</div><div><br></div><di=
v>Sorry if this was already discussed and discarded. &nbsp;I'm not sure if =
there are mechanical benefits to manufacturing T as a function type being l=
everaged (such as being able to pass varargs and properties of a function t=
ype).</div><div><br></div><div><br></div></div></blockquote></div></div>

<p></p>

-- <br />
&nbsp;<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 std-proposals+unsubscribe@isocpp.org.<br />
To post to this group, send email to std-proposals@isocpp.org.<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_1169_30168531.1385612537302--

.


Author: Xeo <hivemaster@hotmail.de>
Date: Thu, 28 Nov 2013 02:20:10 -0800 (PST)
Raw View
------=_Part_1415_592977.1385634010443
Content-Type: text/plain; charset=ISO-8859-1

This style is already used in std::result_of. Also, it resembles normal
invocation:

//                   f(123, 456)
std::invocation_type<F(int, int)>

On Thursday, November 28, 2013 5:04:58 AM UTC+1, Andrew Tomazos wrote:
>
> Just a quick bikeshed comment/query about N3729 std::invocation_type
> http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3729.html:
>
> > std::invocation_type<C(int, int)>::type would be int(double, int). More
> precisely the return type of invocation_type<Fn(ArgTypes...)> is
> result_of<Fn(ArgTypes...)> and each argument type is the same as the
> formal parameter type matched in the call to Fn.
>
> If I understand the interface correctly, the type parameter T to
> std::invocation_type<T> is formed by making a function type R(P1, P2, ...,
> PN) where R is the type of a family of invokable values (not a return type).
>
> On the surface I consider this confusing because you are manufacturing an
> unused function type T just to pass something in its return type which
> isn't a return type.  ie T is never used, it is just unpacked.
>
> Wouldn't the clearer interface be std::invocation_type<C, P1, P2, ..., PN>?
>
> That is:
>
>     namespace std
>     {
>         template <class Fn, class... ArgTypes>
>         struct invocation_type
>         {
>             using type = whatever;
>         };
>     }
>
> So the quoted example would instead read "std::invocation_type<C, int,
> int>::type is int(double, int)"
>
> Sorry if this was already discussed and discarded.  I'm not sure if there
> are mechanical benefits to manufacturing T as a function type being
> leveraged (such as being able to pass varargs and properties of a function
> 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_1415_592977.1385634010443
Content-Type: text/html; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">This style is already used in std::result_of. Also, it res=
embles normal invocation:<br><br><div class=3D"prettyprint" style=3D"backgr=
ound-color: rgb(250, 250, 250); border-color: rgb(187, 187, 187); border-st=
yle: solid; border-width: 1px; word-wrap: break-word;"><code class=3D"prett=
yprint"><div class=3D"subprettyprint"><span style=3D"color: #800;" class=3D=
"styled-by-prettify">// &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &n=
bsp; &nbsp; f(123, 456)</span><span style=3D"color: #000;" class=3D"styled-=
by-prettify"><br>std</span><span style=3D"color: #660;" class=3D"styled-by-=
prettify">::</span><span style=3D"color: #000;" class=3D"styled-by-prettify=
">invocation_type</span><span style=3D"color: #660;" class=3D"styled-by-pre=
ttify">&lt;</span><span style=3D"color: #000;" class=3D"styled-by-prettify"=
>F</span><span style=3D"color: #660;" class=3D"styled-by-prettify">(</span>=
<span style=3D"color: #008;" class=3D"styled-by-prettify">int</span><span s=
tyle=3D"color: #660;" class=3D"styled-by-prettify">,</span><span style=3D"c=
olor: #000;" class=3D"styled-by-prettify"> </span><span style=3D"color: #00=
8;" class=3D"styled-by-prettify">int</span><span style=3D"color: #660;" cla=
ss=3D"styled-by-prettify">)&gt;</span></div></code></div><br>On Thursday, N=
ovember 28, 2013 5:04:58 AM UTC+1, Andrew Tomazos wrote:<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"><font face=3D"arial, sans-seri=
f" size=3D"2">Just a quick bikeshed comment/query about N3729 std::invocati=
on_type&nbsp;<a href=3D"http://www.open-std.org/jtc1/sc22/wg21/docs/papers/=
2013/n3729.html" target=3D"_blank" onmousedown=3D"this.href=3D'http://www.g=
oogle.com/url?q\75http%3A%2F%2Fwww.open-std.org%2Fjtc1%2Fsc22%2Fwg21%2Fdocs=
%2Fpapers%2F2013%2Fn3729.html\46sa\75D\46sntz\0751\46usg\75AFQjCNHlCxaU9vOD=
uwI0OaW4WQucZhH_pw';return true;" onclick=3D"this.href=3D'http://www.google=
..com/url?q\75http%3A%2F%2Fwww.open-std.org%2Fjtc1%2Fsc22%2Fwg21%2Fdocs%2Fpa=
pers%2F2013%2Fn3729.html\46sa\75D\46sntz\0751\46usg\75AFQjCNHlCxaU9vODuwI0O=
aW4WQucZhH_pw';return true;">http://<wbr>www.open-std.org/jtc1/sc22/<wbr>wg=
21/docs/papers/2013/n3729.<wbr>html</a>:</font><div><font face=3D"arial, sa=
ns-serif" size=3D"2"><br></font></div><div><font face=3D"arial, sans-serif"=
 size=3D"2">&gt;&nbsp;<tt style=3D"color:rgb(0,0,0)">std::invocation_type&l=
t;C(int, int)&gt;::type</tt><span style=3D"color:rgb(0,0,0)">&nbsp;would be=
&nbsp;</span><tt style=3D"color:rgb(0,0,0)">int(double, int)</tt><span styl=
e=3D"color:rgb(0,0,0)">. More precisely the return type of&nbsp;</span><tt =
style=3D"color:rgb(0,0,0)">invocation_type&lt;Fn(<wbr>ArgTypes...)&gt;</tt>=
<span style=3D"color:rgb(0,0,0)">&nbsp;is&nbsp;</span><tt style=3D"color:rg=
b(0,0,0)">result_of&lt;Fn(<wbr>ArgTypes...)&gt;</tt><span style=3D"color:rg=
b(0,0,0)">&nbsp;and each argument type is the same as the formal parameter =
type matched in the call to&nbsp;</span><tt style=3D"color:rgb(0,0,0)">Fn</=
tt><span style=3D"color:rgb(0,0,0)">.</span><span style=3D"color:rgb(0,0,0)=
"><br></span></font></div><div><span style=3D"color:rgb(0,0,0)"><font face=
=3D"arial, sans-serif" size=3D"2"><br></font></span></div><div><font color=
=3D"#000000" face=3D"arial, sans-serif" size=3D"2">If I understand the inte=
rface correctly, the type parameter T to std::invocation_type&lt;T&gt; is f=
ormed by making a function type R(P1, P2, ..., PN) where R is the type of a=
 family of invokable values (not a return type).</font></div><div><font col=
or=3D"#000000" face=3D"arial, sans-serif" size=3D"2"><br></font></div><div>=
<font color=3D"#000000" face=3D"arial, sans-serif" size=3D"2">On the surfac=
e I consider this confusing because you are manufacturing an unused functio=
n type T just to pass something in its return type which isn't a return typ=
e. &nbsp;ie T is never used, it is just unpacked.</font></div><div><br></di=
v><div><font color=3D"#000000" face=3D"arial, sans-serif" size=3D"2">Wouldn=
't the clearer interface be std::invocation_type&lt;C, P1, P2, ..., PN&gt;?=
</font></div><div><font style=3D"background-color:rgb(255,255,255)" color=
=3D"#000000" face=3D"arial, sans-serif" size=3D"2"><br></font></div><div><f=
ont style=3D"background-color:rgb(255,255,255)" color=3D"#000000" face=3D"a=
rial, sans-serif" size=3D"2">That is:</font></div><div><font style=3D"backg=
round-color:rgb(255,255,255)" color=3D"#000000" face=3D"arial, sans-serif" =
size=3D"2"><br></font></div><div><div><font face=3D"courier new, monospace"=
><span style=3D"color:rgb(0,0,0);font-size:small">&nbsp; &nbsp; namespace s=
td</span><br></font></div><div><font color=3D"#000000" face=3D"courier new,=
 monospace" size=3D"2">&nbsp; &nbsp; {</font></div><div><font color=3D"#000=
000" face=3D"courier new, monospace" size=3D"2">&nbsp; &nbsp; &nbsp; &nbsp;=
 template &lt;class Fn, class... ArgTypes&gt;</font></div><div><font color=
=3D"#000000" face=3D"courier new, monospace" size=3D"2">&nbsp; &nbsp; &nbsp=
; &nbsp; struct invocation_type</font></div><div><font color=3D"#000000" fa=
ce=3D"courier new, monospace" size=3D"2">&nbsp; &nbsp; &nbsp; &nbsp; {</fon=
t></div><div><font color=3D"#000000" face=3D"courier new, monospace" size=
=3D"2">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; using type =3D whatever;</=
font></div><div><font color=3D"#000000" face=3D"courier new, monospace" siz=
e=3D"2">&nbsp; &nbsp; &nbsp; &nbsp; };</font></div><div><font color=3D"#000=
000" face=3D"courier new, monospace" size=3D"2">&nbsp; &nbsp; }</font></div=
></div><div><br></div><div>So the quoted example would instead read "std::i=
nvocation_type&lt;C, int, int&gt;::type is int(double, int)"</div><div><br>=
</div><div>Sorry if this was already discussed and discarded. &nbsp;I'm not=
 sure if there are mechanical benefits to manufacturing T as a function typ=
e being leveraged (such as being able to pass varargs and properties of a f=
unction type).</div><div><br></div><div><br></div></div></blockquote></div>

<p></p>

-- <br />
&nbsp;<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 std-proposals+unsubscribe@isocpp.org.<br />
To post to this group, send email to std-proposals@isocpp.org.<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_1415_592977.1385634010443--

.