220 26618 <9d82f1b6-b8cb-4b23-98de-329a0889d6b6@isocpp.org> article
Path: news.gmane.org!not-for-mail
From: "smilingthax via ISO C++ Standard - Future Proposals" <std-proposals@isocpp.org>
Newsgroups: gmane.comp.lang.c++.isocpp.proposals
Subject: Re: Pack expansion: blocks, switch/case
Date: Thu, 7 Jul 2016 09:34:46 -0700 (PDT)
Lines: 263
Approved: news@gmane.org
Message-ID: <9d82f1b6-b8cb-4b23-98de-329a0889d6b6@isocpp.org>
References: <c61bd22c-d7c8-4f14-a65f-1a5b7100fa22@isocpp.org>
 <14ddd53c-8ec8-4e73-8f41-ebd8e33c2073@isocpp.org>
 <648eb3c5-488c-4b1b-8be2-02a0ac454220@isocpp.org>
 <c614d89e-9533-42f2-a8aa-d8a1f762a00f@isocpp.org>
 <8b6d75ab-6e5e-44ca-9ec6-c3c853ddbc38@isocpp.org>
 <2c5dbd16-d2c0-4a29-a64b-70b6425f3c55@isocpp.org>
 <24080b48-d084-4c5f-bb3f-fef677baee12@isocpp.org>
Reply-To: std-proposals@isocpp.org
NNTP-Posting-Host: plane.gmane.org
Mime-Version: 1.0
Content-Type: multipart/mixed; 
	boundary="----=_Part_4468_1502830075.1467909286980"
X-Trace: ger.gmane.org 1467909292 17427 80.91.229.3 (7 Jul 2016 16:34:52 GMT)
X-Complaints-To: usenet@ger.gmane.org
NNTP-Posting-Date: Thu, 7 Jul 2016 16:34:52 +0000 (UTC)
Cc: smilingthax@googlemail.com, inkwizytoryankes@gmail.com
To: ISO C++ Standard - Future Proposals <std-proposals@isocpp.org>
Original-X-From: std-proposals+bncBDC63VE4YQPBBKEJ7K5QKGQEO6RTKVI@isocpp.org Thu Jul 07 18:34:52 2016
Return-path: <std-proposals+bncBDC63VE4YQPBBKEJ7K5QKGQEO6RTKVI@isocpp.org>
Envelope-to: gclcip-std-proposals@m.gmane.org
Original-Received: from mail-pf0-f200.google.com ([209.85.192.200])
	by plane.gmane.org with esmtp (Exim 4.69)
	(envelope-from <std-proposals+bncBDC63VE4YQPBBKEJ7K5QKGQEO6RTKVI@isocpp.org>)
	id 1bLCGI-0006OG-An
	for gclcip-std-proposals@m.gmane.org; Thu, 07 Jul 2016 18:34:50 +0200
Original-Received: by mail-pf0-f200.google.com with SMTP id 143sf45072213pfx.0
        for <gclcip-std-proposals@m.gmane.org>; Thu, 07 Jul 2016 09:34:49 -0700 (PDT)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
        d=isocpp-org.20150623.gappssmtp.com; s=20150623;
        h=date:from:to:cc:message-id:in-reply-to:references:subject
         :mime-version:x-original-sender:reply-to:precedence:mailing-list
         :list-id:x-spam-checked-in-group:list-post:list-help:list-archive
         :list-subscribe:list-unsubscribe;
        bh=7MusdJZQ1BOpOacycJ3zmDSNxX/qHjwCQDYfuHFF/jc=;
        b=k2TuLtlI6ytg06Tg/JhSQ/PjeEIPDm623KZ6LHZySFDy7ujJvXdcm0GjrZeuQfJQts
         /ck3k78K3NIjGYzZaYCJHJpu2XzRqtASD4cj6AAcuHInN71PtiewCcbiJP3QXU1hkphm
         M51QHXVeLJ1Pdq0XO9YPEXRmlMjgvFV44HBQUQjwgsuOoj5VNk52UOQB5gBQLW5HJKP/
         9VTsn+pk4RgxsAA1Ri1i8l9a5Ced/2ryu6IYC/MjC3kgI3xky3ViihS4YX31uPVxFT49
         0HJJ22WsbG5A3v0WI4hP9HVhEaDJu8GYo6ybkSiN/sKecAXWMo0HBzpAqdnaSSOdLcUp
         gqZA==
X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
        d=1e100.net; s=20130820;
        h=x-gm-message-state:date:from:to:cc:message-id:in-reply-to
         :references:subject:mime-version:x-original-sender:reply-to
         :precedence:mailing-list:list-id:x-spam-checked-in-group:list-post
         :list-help:list-archive:list-subscribe:list-unsubscribe;
        bh=7MusdJZQ1BOpOacycJ3zmDSNxX/qHjwCQDYfuHFF/jc=;
        b=DXlmbqQMO5ARGJa/JdcH+bnI6NzmQXn11dvd4X3JBc5jXJ7nufDBnISuNv9rBMuCHr
         cZ9Uri1NpMtTBUv1lyt+bte5iDTYn8u3wgNScUn4WTBC1xZKlC1q00ExlZl6vHzzayLE
         EACBwJXIg+fh2aKJFUbvZkEU8YYFJvZ4dYzjPtkkEGHqK1pyLjvJHPp0o9yqzYjNjT9J
         J+yrb+K8RaeC5tqbPzQQtO2ArE2ULUDGCdVa/8t8ZddH+fGPytbP+Me9IqvQpQwHijqV
         06+uIvmKJaF4vCj9/qnRYB1y2ysWYljnwulZUIL1XAWzmyIy9kIJ0je1ts3xSk9UxNJj
         ExFw==
X-Gm-Message-State: ALyK8tLnjvJFxZv+9hLY6WG0GpF51JKXfkscJ+V7qQkHvNbKd67GW+hIWdwb90OOx4r/HQ==
X-Received: by 10.98.22.204 with SMTP id 195mr969409pfw.0.1467909289113;
        Thu, 07 Jul 2016 09:34:49 -0700 (PDT)
X-BeenThere: std-proposals@isocpp.org
Original-Received: by 10.36.129.6 with SMTP id q6ls366607itd.44.gmail; Thu, 07 Jul 2016
 09:34:48 -0700 (PDT)
X-Received: by 10.36.29.72 with SMTP id 69mr287306itj.0.1467909288062;
        Thu, 07 Jul 2016 09:34:48 -0700 (PDT)
In-Reply-To: <24080b48-d084-4c5f-bb3f-fef677baee12@isocpp.org>
X-Original-Sender: smilingthax@googlemail.com
X-Original-From: smilingthax@googlemail.com
Precedence: list
Mailing-list: list std-proposals@isocpp.org; contact std-proposals+owners@isocpp.org
List-ID: <std-proposals.isocpp.org>
X-Spam-Checked-In-Group: std-proposals@isocpp.org
X-Google-Group-Id: 399137483710
List-Post: <https://groups.google.com/a/isocpp.org/group/std-proposals/post>, <mailto:std-proposals@isocpp.org>
List-Help: <https://support.google.com/a/isocpp.org/bin/topic.py?topic=25838>, <mailto:std-proposals+help@isocpp.org>
List-Archive: <https://groups.google.com/a/isocpp.org/group/std-proposals/>
List-Subscribe: <https://groups.google.com/a/isocpp.org/group/std-proposals/subscribe>,
 <mailto:std-proposals+subscribe@isocpp.org>
List-Unsubscribe: <mailto:googlegroups-manage+399137483710+unsubscribe@googlegroups.com>,
 <https://groups.google.com/a/isocpp.org/group/std-proposals/subscribe>
Xref: news.gmane.org gmane.comp.lang.c++.isocpp.proposals:26618
Archived-At: <http://permalink.gmane.org/gmane.comp.lang.c++.isocpp.proposals/26618>

------=_Part_4468_1502830075.1467909286980
Content-Type: multipart/alternative; 
	boundary="----=_Part_4469_1574063416.1467909286980"

------=_Part_4469_1574063416.1467909286980
Content-Type: text/plain; charset=UTF-8

On Thursday, July 7, 2016 at 4:29:05 PM UTC+2, inkwizyt...@gmail.com wrote:
>
> On Thursday, July 7, 2016 at 3:08:34 PM UTC+2, smili...@googlemail.com 
> wrote:
>>
>> Yes, `for constexpr` is far more verbose but this give us lot more 
>> control over that happens. Dots work great when you want expand one 
>> parameter pack but if is more of them or you want start do some complex 
>> thing this will start be problematic.
>>
> Image you want use Cartesian product of two parameters pack. Without 
> introducing completely new syntax you can't handle it.
>

You can implement product<pack<T1...>,pack<T2...>>::type as a library 
solution just like zip<..>. The only difference is that, for 
Us=pair<T1,T2>... you might want to add "using A = Us::first...;" and 
"using B = Us::second...;" for your convenience.
 

> Of corse `for` have limitation too, but is lot of easier remove it.
> Only thing that `for constexpr` need to handle nearly all possible use 
> cases is allow it to extract template parameters from concrete templates 
> (it would need have parameters like `template<typename... T>` or 
> `template<auto... A>`):
> // we have two packs, T1 and T2
> template<typename...> pack{};
>
> for constexpr (typename A : pack<T1..., T2...>) { } //pack merge
> for constexpr (typename A : typename zip<pack<T1...>, pack<T2...>>::type) 
> { } //zip two parameters pack, `type` is `pack<std::pair<T1, T2>...>`
> for constexpr (typename A : pack<T1...>) { for constexpr (typename B : 
> pack<T2...>) { } } //cross of two packs, this could be same pack too
> for constexpr (typename A : pack<int, long, char>) { } //usage without 
> any parameter pack and outside any template
>
> And for `break` and `continue`. Only real problem there is `continue` 
> because `break` can be easy fix by adding one after `for`. Another is this 
> interaction should be well know for every one because is already same for 
> normal loops: [...]
>
 
The for constexpr proposal meshes two things together that don't have to: 
One half is the semantic of "for", esp. wrt. to the creation of a 
break/continue-scope. The other half is the "inline"-introduction of a new 
parameter pack (i.e. without another indirection like function call / 
template class). 

The first half is IMO only weakly motivated; when you think of it, even the 
name "for constexpr" is not exactly fitting, because you're (most 
importantly) dealing with *types*, not constexpr 
*values.*
The second half can be dealt with without touching break/continue - or even 
forcing an expansion. Think about:

  using... Us = pack<int,char,long>;
  // ...
  { doSomething<Us> }...
  // ...

That's just a simple example, but the same thing works the same with 
product, zip, and all the stuff from above (you can add "using A = 
Ts::first;" as you like).

The real questions are: How will "using..." (or "for constexpr") know how 
to "iterate the pack", i.e. find the variadic part? 
When we look at how range-for was specified, we can see that it does not 
"bless" a certain "range"-type, but uses whatever iterator begin() / end() 
would return. So we're now talking about "meta"-iterators over types, like 
Boost MPL - or Fusion - or Hana - or ... has. It's not like the *one true *solution 
in this space has already been around long enough just waiting to get 
standardized.

Anyway, I don't think these considerations should hold us back from adding 
a *simple *statment/block-expansion facility to the language that already 
solves 95% of the most common use-cases.

  Tobias

 

-- 
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/9d82f1b6-b8cb-4b23-98de-329a0889d6b6%40isocpp.org.

------=_Part_4469_1574063416.1467909286980
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">On Thursday, July 7, 2016 at 4:29:05 PM UTC+2, inkwizyt...=
@gmail.com wrote:<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">On Thursday, July 7, 2016 at 3:08:34 PM UTC+2, <a>smili...@googlemail.c=
om</a> wrote:<blockquote class=3D"gmail_quote" style=3D"margin:0;margin-lef=
t:0.8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr">Yes, =
`for constexpr` is far more verbose but this give us lot more control over =
that happens. Dots work great when you want expand one parameter pack but i=
f is more of them or you want start do some complex thing this will start b=
e problematic.<br></div></blockquote><div>Image you want use Cartesian prod=
uct of two parameters pack. Without introducing completely new syntax you c=
an&#39;t handle it.</div></div></blockquote><div><br></div><div>You can imp=
lement product&lt;pack&lt;T1...&gt;,pack&lt;T2...&gt;&gt;::type as a librar=
y solution just like zip&lt;..&gt;. The only difference is that, for Us=3Dp=
air&lt;T1,T2&gt;... you might want to add &quot;using A =3D Us::first...;&q=
uot; and &quot;using B =3D Us::second...;&quot; for your convenience.</div>=
<div>=C2=A0</div><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> Of corse `for` have limitation too, but is lot of easier remove i=
t.<br>Only thing that `for constexpr` need to handle nearly all possible us=
e cases is allow it to extract template parameters from concrete templates =
(it would need have parameters like `template&lt;typename... T&gt;` or `tem=
plate&lt;auto... A&gt;`):<br><div style=3D"background-color:rgb(250,250,250=
);border-color:rgb(187,187,187);border-style:solid;border-width:1px;word-wr=
ap:break-word"><code><div><span style=3D"color:#800">// we have two packs, =
T1 and T2</span><span style=3D"color:#000"><br></span><span style=3D"color:=
#008">template</span><span style=3D"color:#660">&lt;</span><span style=3D"c=
olor:#008">typename</span><span style=3D"color:#660">...&gt;</span><span st=
yle=3D"color:#000"> pack</span><span style=3D"color:#660">{};</span><span s=
tyle=3D"color:#000"><br><br></span><span style=3D"color:#008">for</span><sp=
an style=3D"color:#000"> </span><span style=3D"color:#008">constexpr</span>=
<span style=3D"color:#000"> </span><span style=3D"color:#660">(</span><span=
 style=3D"color:#008">typename</span><span style=3D"color:#000"> A </span><=
span style=3D"color:#660">:</span><span style=3D"color:#000"> pack</span><s=
pan style=3D"color:#660">&lt;</span><span style=3D"color:#000">T1</span><sp=
an style=3D"color:#660">...,</span><span style=3D"color:#000"> T2</span><sp=
an style=3D"color:#660">...&gt;)</span><span style=3D"color:#000"> </span><=
span style=3D"color:#660">{</span><span style=3D"color:#000"> </span><span =
style=3D"color:#660">}</span><span style=3D"color:#000"> </span><span style=
=3D"color:#800">//pack merge</span><span style=3D"color:#000"><br></span><s=
pan style=3D"color:#008">for</span><span style=3D"color:#000"> </span><span=
 style=3D"color:#008">constexpr</span><span style=3D"color:#000"> </span><s=
pan style=3D"color:#660">(</span><span style=3D"color:#008">typename</span>=
<span style=3D"color:#000"> A </span><span style=3D"color:#660">:</span><sp=
an style=3D"color:#000"> </span><span style=3D"color:#008">typename</span><=
span style=3D"color:#000"> zip</span><span style=3D"color:#660">&lt;</span>=
<span style=3D"color:#000">pack</span><span style=3D"color:#660">&lt;</span=
><span style=3D"color:#000">T1</span><span style=3D"color:#660">...&gt;,</s=
pan><span style=3D"color:#000"> pack</span><span style=3D"color:#660">&lt;<=
/span><span style=3D"color:#000">T2</span><span style=3D"color:#660">...&gt=
;&gt;::</span><span style=3D"color:#000">type</span><span style=3D"color:#6=
60">)</span><span style=3D"color:#000"> </span><span style=3D"color:#660">{=
</span><span style=3D"color:#000"> </span><span style=3D"color:#660">}</spa=
n><span style=3D"color:#000"> </span><span style=3D"color:#800">//zip two p=
arameters pack, `type` is `pack&lt;std::pair&lt;T1, T2&gt;...&gt;`</span><s=
pan style=3D"color:#000"><br></span><span style=3D"color:#008">for</span><s=
pan style=3D"color:#000"> </span><span style=3D"color:#008">constexpr</span=
><span style=3D"color:#000"> </span><span style=3D"color:#660">(</span><spa=
n style=3D"color:#008">typename</span><span style=3D"color:#000"> A </span>=
<span style=3D"color:#660">:</span><span style=3D"color:#000"> pack</span><=
span style=3D"color:#660">&lt;</span><span style=3D"color:#000">T1</span><s=
pan style=3D"color:#660">...&gt;)</span><span style=3D"color:#000"> </span>=
<span style=3D"color:#660">{</span><span style=3D"color:#000"> </span><span=
 style=3D"color:#008">for</span><span style=3D"color:#000"> </span><span st=
yle=3D"color:#008">constexpr</span><span style=3D"color:#000"> </span><span=
 style=3D"color:#660">(</span><span style=3D"color:#008">typename</span><sp=
an style=3D"color:#000"> B </span><span style=3D"color:#660">:</span><span =
style=3D"color:#000"> pack</span><span style=3D"color:#660">&lt;</span><spa=
n style=3D"color:#000">T2</span><span style=3D"color:#660">...&gt;)</span><=
span style=3D"color:#000"> </span><span style=3D"color:#660">{</span><span =
style=3D"color:#000"> </span><span style=3D"color:#660">}</span><span style=
=3D"color:#000"> </span><span style=3D"color:#660">}</span><span style=3D"c=
olor:#000"> </span><span style=3D"color:#800">//cross of two packs, this co=
uld be same pack too</span><span style=3D"color:#000"><br></span><span styl=
e=3D"color:#008">for</span><span style=3D"color:#000"> </span><span style=
=3D"color:#008">constexpr</span><span style=3D"color:#000"> </span><span st=
yle=3D"color:#660">(</span><span style=3D"color:#008">typename</span><span =
style=3D"color:#000"> A </span><span style=3D"color:#660">:</span><span sty=
le=3D"color:#000"> pack</span><span style=3D"color:#660">&lt;</span><span s=
tyle=3D"color:#008">int</span><span style=3D"color:#660">,</span><span styl=
e=3D"color:#000"> </span><span style=3D"color:#008">long</span><span style=
=3D"color:#660">,</span><span style=3D"color:#000"> </span><span style=3D"c=
olor:#008">char</span><span style=3D"color:#660">&gt;)</span><span style=3D=
"color:#000"> </span><span style=3D"color:#660">{</span><span style=3D"colo=
r:#000"> </span><span style=3D"color:#660">}</span><span style=3D"color:#00=
0"> </span><span style=3D"color:#800">//usage without any parameter pack an=
d outside any template</span><span style=3D"color:#000"><br></span></div></=
code></div><br>And for `break` and `continue`. Only real problem there is `=
continue` because `break` can be easy fix by adding one after `for`. Anothe=
r is this interaction should be well know for every one because is already =
same for normal loops: [...]</div></div></blockquote><div>=C2=A0</div><div>=
The for constexpr proposal meshes two things together that don&#39;t have t=
o: One half is the semantic of &quot;for&quot;, esp. wrt. to the creation o=
f a break/continue-scope. The other half is the &quot;inline&quot;-introduc=
tion of a new parameter pack (i.e. without another indirection like functio=
n call / template class).=C2=A0</div><div><br>The first half is IMO only we=
akly motivated; when you think of it, even the name &quot;for constexpr&quo=
t; is not exactly fitting, because you&#39;re (most importantly) dealing wi=
th <i>types</i>, not constexpr <i>values.<br></i><br>The second half can be=
 dealt with without touching break/continue - or even forcing an expansion.=
 Think about:<br><br></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"><spa=
n style=3D"color: #000;" class=3D"styled-by-prettify">=C2=A0 </span><span s=
tyle=3D"color: #008;" class=3D"styled-by-prettify">using</span><span style=
=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: #606;=
" class=3D"styled-by-prettify">Us</span><span style=3D"color: #000;" class=
=3D"styled-by-prettify"> </span><span style=3D"color: #660;" class=3D"style=
d-by-prettify">=3D</span><span style=3D"color: #000;" class=3D"styled-by-pr=
ettify"> pack</span><span style=3D"color: #660;" class=3D"styled-by-prettif=
y">&lt;</span><span style=3D"color: #008;" class=3D"styled-by-prettify">int=
</span><span style=3D"color: #660;" class=3D"styled-by-prettify">,</span><s=
pan style=3D"color: #008;" class=3D"styled-by-prettify">char</span><span st=
yle=3D"color: #660;" class=3D"styled-by-prettify">,</span><span style=3D"co=
lor: #008;" class=3D"styled-by-prettify">long</span><span style=3D"color: #=
660;" class=3D"styled-by-prettify">&gt;;</span><span style=3D"color: #000;"=
 class=3D"styled-by-prettify"><br>=C2=A0 </span><span style=3D"color: #800;=
" class=3D"styled-by-prettify">// ...</span><span style=3D"color: #000;" cl=
ass=3D"styled-by-prettify"><br>=C2=A0 </span><span style=3D"color: #660;" c=
lass=3D"styled-by-prettify">{</span><span style=3D"color: #000;" class=3D"s=
tyled-by-prettify"> doSomething</span><span style=3D"color: #660;" class=3D=
"styled-by-prettify">&lt;</span><span style=3D"color: #606;" class=3D"style=
d-by-prettify">Us</span><span style=3D"color: #660;" class=3D"styled-by-pre=
ttify">&gt;</span><span style=3D"color: #000;" class=3D"styled-by-prettify"=
> </span><span style=3D"color: #660;" class=3D"styled-by-prettify">}...</sp=
an><span style=3D"color: #000;" class=3D"styled-by-prettify"><br>=C2=A0 </s=
pan><span style=3D"color: #800;" class=3D"styled-by-prettify">// ...</span>=
<span style=3D"color: #000;" class=3D"styled-by-prettify"><br></span></div>=
</code></div><div><br></div><div>That&#39;s just a simple example, but the =
same thing works the same with product, zip, and all the stuff from above (=
you can add &quot;using A =3D Ts::first;&quot; as you like).<br><br>The rea=
l questions are: How will &quot;using...&quot; (or &quot;for constexpr&quot=
;) know how to &quot;iterate the pack&quot;, i.e. find the variadic part?=
=C2=A0<br>When we look at how range-for was specified, we can see that it d=
oes not &quot;bless&quot; a certain &quot;range&quot;-type, but uses whatev=
er iterator begin() / end() would return. So we&#39;re now talking about &q=
uot;meta&quot;-iterators over types, like Boost MPL - or Fusion - or Hana -=
 or ... has. It&#39;s not like the <i>one true </i>solution in this space h=
as already been around long enough just waiting to get standardized.<br><br=
>Anyway, I don&#39;t think these considerations should hold us back from ad=
ding a <i>simple </i>statment/block-expansion facility to the language that=
 already solves 95% of the most common use-cases.</div><div><br></div><div>=
=C2=A0 Tobias<br><br></div><div>=C2=A0</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/9d82f1b6-b8cb-4b23-98de-329a0889d6b6%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/9d82f1b6-b8cb-4b23-98de-329a0889d6b6=
%40isocpp.org</a>.<br />

------=_Part_4469_1574063416.1467909286980--

------=_Part_4468_1502830075.1467909286980--

.
