------=_Part_6645_1406012289.1530243908722
Content-Type: multipart/alternative;
 boundary="----=_Part_6646_1367950922.1530243908722"

------=_Part_6646_1367950922.1530243908722
Content-Type: text/plain; charset="UTF-8"

During the process of implementing the proposal P0957
(https://wg21.link/p0957), I found that if the concept of "Trivially
Swappable" is defined, the performance of the implementation of will be
improved to a certain extent without reducing usability.

For instance, in the move constructor of a value-semantics-based
polymorphic wrapper (e.g., `std::function`, `std::any` or the `proxy` in
P0957) with SBO (Small Buffer Optimization, aka. SOO, Small Object
Optimization), if the value being type-erased is not guaranteed to be
trivially swappable, the implementation should always make an indirect call
to the concrete move constructor when moving the value from one buffer to
another. If we have the concept of "Trivially Swappable", the overhead can
be eliminated. This feature could also help in GC-based situations.

I am also wondering if this concept could help in generating default move
constructors.

I am looking forward to your comments!

Mingxin Wang

--
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.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/32127fd5-bf28-480d-82cb-c1ed77f1f83d%40isocpp.org.

------=_Part_6646_1367950922.1530243908722
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div>During the process of implementing the proposal P0957=
 (https://wg21.link/p0957), I found that if the concept of &quot;Trivially =
Swappable&quot; is defined, the performance of the implementation of will b=
e improved to a certain extent without reducing usability.</div><div><br></=
div><div>For instance, in the move constructor of a value-semantics-based p=
olymorphic wrapper (e.g., `std::function`, `std::any` or the `proxy` in P09=
57) with SBO (Small Buffer Optimization, aka. SOO, Small Object Optimizatio=
n), if the value being type-erased is not guaranteed to be trivially swappa=
ble, the implementation should always make an indirect call to the concrete=
 move constructor when moving the value from one buffer to another. If we h=
ave the concept of &quot;Trivially Swappable&quot;, the overhead can be eli=
minated. This feature could also help in GC-based situations.</div><div><br=
></div><div>I am also wondering if this concept could help in generating de=
fault move constructors.</div><div><br></div><div>I am looking forward to y=
our comments!</div><div><br></div><div>Mingxin Wang</div></div>

<p></p>

-- <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 />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/32127fd5-bf28-480d-82cb-c1ed77f1f83d%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/32127fd5-bf28-480d-82cb-c1ed77f1f83d=
%40isocpp.org</a>.<br />

------=_Part_6646_1367950922.1530243908722--

------=_Part_6645_1406012289.1530243908722--

.

------=_Part_9641_1127616934.1530245765802
Content-Type: multipart/alternative;
 boundary="----=_Part_9642_1950277730.1530245765803"

------=_Part_9642_1950277730.1530245765803
Content-Type: text/plain; charset="UTF-8"

On Thursday, June 28, 2018 at 11:45:08 PM UTC-4, Mingxin Wang wrote:
>
> During the process of implementing the proposal P0957 (
> https://wg21.link/p0957), I found that if the concept of "Trivially
> Swappable" is defined, the performance of the implementation of will be
> improved to a certain extent without reducing usability.
>

OK, so... what would this concept mean? Can you provide a definition of
these requirements and what they would allow you to do?

I am also wondering if this concept could help in generating default move
> constructors.
>

Do we need help generating default move constructors? Is `= default` not
good enough? Or are you talking about something else?

--
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.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/160379e6-766d-4a8b-a438-e17d7cd6bf03%40isocpp.org.

------=_Part_9642_1950277730.1530245765803
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">On Thursday, June 28, 2018 at 11:45:08 PM UTC-4, Mingxin W=
ang wrote:<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"><di=
v>During the process of implementing the proposal P0957 (<a href=3D"https:/=
/wg21.link/p0957" target=3D"_blank" rel=3D"nofollow" onmousedown=3D"this.hr=
ef=3D&#39;https://www.google.com/url?q\x3dhttps%3A%2F%2Fwg21.link%2Fp0957\x=
26sa\x3dD\x26sntz\x3d1\x26usg\x3dAFQjCNFdptJYcczvIDp0ZD4G76apo22UOw&#39;;re=
turn true;" onclick=3D"this.href=3D&#39;https://www.google.com/url?q\x3dhtt=
ps%3A%2F%2Fwg21.link%2Fp0957\x26sa\x3dD\x26sntz\x3d1\x26usg\x3dAFQjCNFdptJY=
cczvIDp0ZD4G76apo22UOw&#39;;return true;">https://wg21.link/p0957</a>), I f=
ound that if the concept of &quot;Trivially Swappable&quot; is defined, the=
 performance of the implementation of will be improved to a certain extent =
without reducing usability.</div></div></blockquote><div><br></div><div>OK,=
 so... what would this concept mean? Can you provide a definition of these =
requirements and what they would allow you to do?</div><div><br></div><bloc=
kquote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-l=
eft: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><div></div><div>I =
am also wondering if this concept could help in generating default move con=
structors.</div></div></blockquote><div><br></div><div>Do we need help gene=
rating default move constructors? Is `=3D default` not good enough? Or are =
you talking about something else?</div><br></div>

<p></p>

-- <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 />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/160379e6-766d-4a8b-a438-e17d7cd6bf03%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/160379e6-766d-4a8b-a438-e17d7cd6bf03=
%40isocpp.org</a>.<br />

------=_Part_9642_1950277730.1530245765803--

------=_Part_9641_1127616934.1530245765802--

.

------=_Part_10763_1635236509.1530256780949
Content-Type: multipart/alternative;
 boundary="----=_Part_10764_1297465635.1530256780949"

------=_Part_10764_1297465635.1530256780949
Content-Type: text/plain; charset="UTF-8"


On Friday, June 29, 2018 at 12:16:05 PM UTC+8, Nicol Bolas wrote:
>
> On Thursday, June 28, 2018 at 11:45:08 PM UTC-4, Mingxin Wang wrote:
>>
>> During the process of implementing the proposal P0957 (
>> https://wg21.link/p0957), I found that if the concept of "Trivially
>> Swappable" is defined, the performance of the implementation of will be
>> improved to a certain extent without reducing usability.
>>
>
> OK, so... what would this concept mean? Can you provide a definition of
> these requirements and what they would allow you to do?
>

Informally, a type meets the *TriviallySwappable* requirements if the
"std::swap" function overload of this type performs bitwise swap operation.


>
> I am also wondering if this concept could help in generating default move
>> constructors.
>>
>
> Do we need help generating default move constructors? Is `= default` not
> good enough? Or are you talking about something else?
>

If the construction of a type involves heap allocation with exclusive
ownership, e.g. `std::unique_ptr`, the default move constructor will not
work. But as long as `std::unique_ptr` is TriviallySwappable and
DefaultConstructible, the move constructor could be generated with the
default constructor and bitwise swap, which is equivalent to the semantics
defined in the standard.

--
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.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/18469feb-bdda-466d-ba8c-37933c1ea807%40isocpp.org.

------=_Part_10764_1297465635.1530256780949
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><br>On Friday, June 29, 2018 at 12:16:05 PM UTC+8, Nicol B=
olas wrote:<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">On=
 Thursday, June 28, 2018 at 11:45:08 PM UTC-4, Mingxin Wang wrote:<blockquo=
te class=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;border-left:1p=
x #ccc solid;padding-left:1ex"><div dir=3D"ltr"><div>During the process of =
implementing the proposal P0957 (<a href=3D"https://wg21.link/p0957" rel=3D=
"nofollow" target=3D"_blank" onmousedown=3D"this.href=3D&#39;https://www.go=
ogle.com/url?q\x3dhttps%3A%2F%2Fwg21.link%2Fp0957\x26sa\x3dD\x26sntz\x3d1\x=
26usg\x3dAFQjCNFdptJYcczvIDp0ZD4G76apo22UOw&#39;;return true;" onclick=3D"t=
his.href=3D&#39;https://www.google.com/url?q\x3dhttps%3A%2F%2Fwg21.link%2Fp=
0957\x26sa\x3dD\x26sntz\x3d1\x26usg\x3dAFQjCNFdptJYcczvIDp0ZD4G76apo22UOw&#=
39;;return true;">https://wg21.link/p0957</a>), I found that if the concept=
 of &quot;Trivially Swappable&quot; is defined, the performance of the impl=
ementation of will be improved to a certain extent without reducing usabili=
ty.</div></div></blockquote><div><br></div><div>OK, so... what would this c=
oncept mean? Can you provide a definition of these requirements and what th=
ey would allow you to do?</div></div></blockquote><div><br></div><div>Infor=
mally, a type meets the <b>TriviallySwappable</b> requirements if the &quot=
;std::swap&quot; function overload of this type performs bitwise swap opera=
tion.</div><div>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"marg=
in: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><d=
iv dir=3D"ltr"><div><br></div><blockquote class=3D"gmail_quote" style=3D"ma=
rgin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-left:1ex"><div =
dir=3D"ltr"><div></div><div>I am also wondering if this concept could help =
in generating default move constructors.</div></div></blockquote><div><br><=
/div><div>Do we need help generating default move constructors? Is `=3D def=
ault` not good enough? Or are you talking about something else?</div></div>=
</blockquote><div><br></div><div>If the construction of a type involves hea=
p allocation with exclusive ownership, e.g. `std::unique_ptr`, the default =
move constructor will not work. But as long as `std::unique_ptr` is Trivial=
lySwappable and DefaultConstructible, the move constructor could be generat=
ed with the default constructor and bitwise swap, which is=C2=A0equivalent =
to the semantics defined in the standard.</div></div>

<p></p>

-- <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 />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/18469feb-bdda-466d-ba8c-37933c1ea807%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/18469feb-bdda-466d-ba8c-37933c1ea807=
%40isocpp.org</a>.<br />

------=_Part_10764_1297465635.1530256780949--

------=_Part_10763_1635236509.1530256780949--

.

------=_Part_12336_1360040826.1530275562493
Content-Type: multipart/alternative;
 boundary="----=_Part_12337_420122815.1530275562494"

------=_Part_12337_420122815.1530275562494
Content-Type: text/plain; charset="UTF-8"



On Friday, June 29, 2018 at 9:19:41 AM UTC+2, Mingxin Wang wrote:
>
>
> On Friday, June 29, 2018 at 12:16:05 PM UTC+8, Nicol Bolas wrote:
>>
>> On Thursday, June 28, 2018 at 11:45:08 PM UTC-4, Mingxin Wang wrote:
>>>
>>> During the process of implementing the proposal P0957 (
>>> https://wg21.link/p0957), I found that if the concept of "Trivially
>>> Swappable" is defined, the performance of the implementation of will be
>>> improved to a certain extent without reducing usability.
>>>
>>
>> OK, so... what would this concept mean? Can you provide a definition of
>> these requirements and what they would allow you to do?
>>
>
> Informally, a type meets the *TriviallySwappable* requirements if the
> "std::swap" function overload of this type performs bitwise swap operation.
>
>
And how you detect/define this? Probably best way would be if function
`bit_swap(&a, &b)` exists. This function could work for relocate too (you
swap with uninitialized memory).


>
>> I am also wondering if this concept could help in generating default move
>>> constructors.
>>>
>>
>> Do we need help generating default move constructors? Is `= default` not
>> good enough? Or are you talking about something else?
>>
>
> If the construction of a type involves heap allocation with exclusive
> ownership, e.g. `std::unique_ptr`, the default move constructor will not
> work. But as long as `std::unique_ptr` is TriviallySwappable and
> DefaultConstructible, the move constructor could be generated with the
> default constructor and bitwise swap, which is equivalent to the semantics
> defined in the standard.
>

--
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.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/d03637a6-0d2b-45b0-b07e-d32320ec984b%40isocpp.org.

------=_Part_12337_420122815.1530275562494
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><br><br>On Friday, June 29, 2018 at 9:19:41 AM UTC+2, Ming=
xin Wang wrote:<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=
"><br>On Friday, June 29, 2018 at 12:16:05 PM UTC+8, Nicol Bolas wrote:<blo=
ckquote class=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;border-le=
ft:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr">On Thursday, June 28, =
2018 at 11:45:08 PM UTC-4, Mingxin Wang wrote:<blockquote class=3D"gmail_qu=
ote" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding=
-left:1ex"><div dir=3D"ltr"><div>During the process of implementing the pro=
posal P0957 (<a href=3D"https://wg21.link/p0957" rel=3D"nofollow" target=3D=
"_blank" onmousedown=3D"this.href=3D&#39;https://www.google.com/url?q\x3dht=
tps%3A%2F%2Fwg21.link%2Fp0957\x26sa\x3dD\x26sntz\x3d1\x26usg\x3dAFQjCNFdptJ=
YcczvIDp0ZD4G76apo22UOw&#39;;return true;" onclick=3D"this.href=3D&#39;http=
s://www.google.com/url?q\x3dhttps%3A%2F%2Fwg21.link%2Fp0957\x26sa\x3dD\x26s=
ntz\x3d1\x26usg\x3dAFQjCNFdptJYcczvIDp0ZD4G76apo22UOw&#39;;return true;">ht=
tps://wg21.link/p0957</a>), I found that if the concept of &quot;Trivially =
Swappable&quot; is defined, the performance of the implementation of will b=
e improved to a certain extent without reducing usability.</div></div></blo=
ckquote><div><br></div><div>OK, so... what would this concept mean? Can you=
 provide a definition of these requirements and what they would allow you t=
o do?</div></div></blockquote><div><br></div><div>Informally, a type meets =
the <b>TriviallySwappable</b> requirements if the &quot;std::swap&quot; fun=
ction overload of this type performs bitwise swap operation.</div><div>=C2=
=A0</div></div></blockquote><div>And how you detect/define this? Probably b=
est way would be if function `bit_swap(&amp;a, &amp;b)` exists. This functi=
on could work for relocate too (you swap with uninitialized memory).</div><=
div>=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"lt=
r"><blockquote class=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;bo=
rder-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><div><br></div>=
<blockquote class=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;borde=
r-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><div></div><div>I =
am also wondering if this concept could help in generating default move con=
structors.</div></div></blockquote><div><br></div><div>Do we need help gene=
rating default move constructors? Is `=3D default` not good enough? Or are =
you talking about something else?</div></div></blockquote><div><br></div><d=
iv>If the construction of a type involves heap allocation with exclusive ow=
nership, e.g. `std::unique_ptr`, the default move constructor will not work=
.. But as long as `std::unique_ptr` is TriviallySwappable and DefaultConstru=
ctible, the move constructor could be generated with the default constructo=
r and bitwise swap, which is=C2=A0equivalent to the semantics defined in th=
e standard.</div></div></blockquote></div>

<p></p>

-- <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 />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/d03637a6-0d2b-45b0-b07e-d32320ec984b%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/d03637a6-0d2b-45b0-b07e-d32320ec984b=
%40isocpp.org</a>.<br />

------=_Part_12337_420122815.1530275562494--

------=_Part_12336_1360040826.1530275562493--

.

------=_Part_17040_1974917887.1530317303044
Content-Type: multipart/alternative;
 boundary="----=_Part_17041_307742624.1530317303044"

------=_Part_17041_307742624.1530317303044
Content-Type: text/plain; charset="UTF-8"

On Friday, June 29, 2018 at 8:32:42 PM UTC+8, Marcin Jaczewski wrote:
>
> On Friday, June 29, 2018 at 9:19:41 AM UTC+2, Mingxin Wang wrote:
>>
>> Informally, a type meets the *TriviallySwappable* requirements if the
>> "std::swap" function overload of this type performs bitwise swap operation.
>>
>>
> And how you detect/define this? Probably best way would be if function
> `bit_swap(&a, &b)` exists. This function could work for relocate too (you
> swap with uninitialized memory).
>

I think we can have a special type traits `std::is_trivially_swappable`,
and `std::is_trivially_swappable<T>::value` is always `true`. Users may
provide specializations that make it `false` indicating a type is NOT
trivially swappable. After all, in most cases I have seen where you do not
want to print the absolute value of `this`, the types always meet the
TriviallySwappable requirements.

--
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.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/498e1019-58d8-44e3-b7dc-461bacb208cf%40isocpp.org.

------=_Part_17041_307742624.1530317303044
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">On Friday, June 29, 2018 at 8:32:42 PM UTC+8, Marcin Jacze=
wski wrote:<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">On=
 Friday, June 29, 2018 at 9:19:41 AM UTC+2, Mingxin Wang wrote:<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>Informally, a type meets =
the <b>TriviallySwappable</b> requirements if the &quot;std::swap&quot; fun=
ction overload of this type performs bitwise swap operation.</div><div>=C2=
=A0</div></div></blockquote><div>And how you detect/define this? Probably b=
est way would be if function `bit_swap(&amp;a, &amp;b)` exists. This functi=
on could work for relocate too (you swap with uninitialized memory).</div><=
/div></blockquote><div><br></div><div>I think we can have a special type tr=
aits `std::is_trivially_swappable`, and `std::is_trivially_swappable&lt;T&g=
t;::value` is always `true`. Users may provide specializations that make it=
 `false` indicating a type is NOT trivially swappable. After all, in most c=
ases I have seen where you do not want to print the absolute value of `this=
`, the types always meet the TriviallySwappable requirements.</div></div>

<p></p>

-- <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 />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/498e1019-58d8-44e3-b7dc-461bacb208cf%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/498e1019-58d8-44e3-b7dc-461bacb208cf=
%40isocpp.org</a>.<br />

------=_Part_17041_307742624.1530317303044--

------=_Part_17040_1974917887.1530317303044--

.