Topic: [RFC] Generalized Unpacking and Parameter Pack Slicing
Author: Matthew Woehlke <mwoehlke.floss@gmail.com>
Date: Mon, 19 Dec 2016 14:19:53 -0500
Raw View
This is a multi-part message in MIME format.
--------------050205010902060401060803
Content-Type: text/plain; charset=UTF-8
I've talked about this on numerous occasions... here at last is a formal
paper. Comments appreciated!
I'd also appreciate if anyone has good, concrete examples for why
extracting single elements from a pack is useful.
Short Summary:
--------------
Add a syntax for slicing parameter packs. Extend this syntax to also
work on product types. Gain ability to convert a product type to a
parameter pack in the process.
Longer summary:
---------------
This is a two-part proposal.
The first part proposes to add parameter pack slicing, of the form
`[I]pack` or `[L:U]pack`. The first syntax says to take the `I`th
element of the pack, and produces a single value. The second syntax says
to take the elements of the pack with indices from `L` (inclusive) until
`U` (exclusive), and produces a modified pack. Either bound may be
omitted, and negative indices may be used to indicate 'count from end'
semantics. Accordingly, `[:]pack` is a no-op. (Slicing has higher
precedence than fold expansion. Refer to the paper for more specifics.)
The second part proposes that parameter pack operations, particularly
slicing (as in the first part), but also (optionally) `sizeof...`,
should also work on product types as well as packs. Critically, this
means that the following would now be semantically equivalent:
std::apply(foo, pt);
foo([:]pt...);
Please refer to the paper for motivating examples.
Postscript:
-----------
Some links in this are known to be broken, as they are intended to refer
to my other draft proposal re: allowing types to be defined in return
type specifications. See also
https://groups.google.com/a/isocpp.org/forum/#!topic/std-proposals/y7dyHcD_BKA.
--
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.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/585832D9.7010208%40gmail.com.
--------------050205010902060401060803
Content-Type: text/prs.fallenstein.rst;
name="dxxxx-generalized-unpacking.rst"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: attachment;
filename="dxxxx-generalized-unpacking.rst"
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D
Generalized Unpacking and Parameter Pack Slicing
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D
:Document: Dxxxx
:Date: 2016-12-19
:Project: ISO/IEC JTC1 SC22 WG21 Programming Language C++
:Audience: Evolution Working Group
:Author: Matthew Woehlke (mwoehlke.floss@gmail.com)
=2E. raw:: html
<style>
html { color: black; background: white; }
table.docinfo { margin: 2em 0; }
</style>
=2E. role:: cpp(code)
:language: c++
Abstract
=3D=3D=3D=3D=3D=3D=3D=3D
This proposal introduces two new, related concepts: "generalized unpackin=
g" (the conversion of product types to parameter packs) and parameter pac=
k slicing. These concepts use the same syntax and may be employed concurr=
ently.
=2E. contents::
Background
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
There is an increasing push in C++ to add interoperability between values=
and value sequences, exemplified by the recent addition of "structured b=
inding", :cpp:`std::apply`, and :cpp:`std::make_from_tuple` in C++17, and=
by proposals such as P0327_ that work toward expanding and clarifying th=
e concept of value sequences (using the term "product type") and P0341_ w=
hich proposes certain mechanisms for using product types. Similar feature=
s have long been present in other languages, with Python frequently held =
up as a representative example. While we feel that these represent steps =
in the right direction, there remain problems to be solved.
Rationale
=3D=3D=3D=3D=3D=3D=3D=3D=3D
Parameter pack slicing, particularly single valued slicing, solves a know=
n problem when working with parameter packs. Several algorithms and ideas=
for working with parameter packs require the ability to select an item f=
rom a parameter pack by index.
Generalized unpacking greatly expands the ability to work with product ty=
pes. Although :cpp:`std::apply` and :cpp:`std::make_from_tuple` attempt t=
o fill some of these roles, their mere existence, and especially that the=
y are two separate functions despite serving conceptually identical purpo=
ses, is indicative of the usefulness of a language feature. Moreover, the=
se functions have significant limitations: they can only cover specific u=
se cases, they cannot perform slicing operations on their own, and they c=
annot be readily used where the desired argument list *includes* but does=
not *solely consist of* a single product type.
Although we could attempt to solve these issues independently, we believe=
it is better to approach them together.
Proposal
=3D=3D=3D=3D=3D=3D=3D=3D
We present our proposal in two parts. First, we present the proposed synt=
ax and examine its function in the context of parameter packs. Second, we=
extend the application of the proposed syntax to also incorporate "concr=
ete" product types.
Parameter Pack Slicing
----------------------
We propose to introduce a new prefix operator, ```[` <slicing_expression>=
`]```, which may be applied to an expression producing a parameter pack.=
The syntax of ``<slicing_expression>`` shall be one of ``<index>`` or ``=
[<index>] `:` [<index>]``, where each ``<index>`` is a :cpp:`constexpr` o=
f integer type. For the purposes of the following specification, also let=
``<pack_expression>`` be the operand of the slicing expression.
The first form shall select a *single* element of a pack, and shall yield=
this value as a single value (i.e. not as a new pack). For example, the =
expression :cpp:`[1]pack` shall yield the second value of the parameter p=
ack :cpp:`pack`. If the ``<index>`` is negative, it shall first be added =
to :cpp:`sizeof...(<pack_expression>)`. If the index (after the preceding=
step, if applicable) is out of bounds, the expression shall be ill-forme=
d.
The second form shall return a *variable* slice of the parameter pack, an=
d shall yield this value as a new parameter pack. Both indices are option=
al and may be omitted. The first ``<index>`` shall specify the index of t=
he first pack element to yield. If omitted, the value :cpp:`0` shall be a=
ssumed. The second ``<index>`` shall specify the *upper bound* on the ind=
ices to be yielded, meaning that the specified index is *not* included. I=
f omitted, the value :cpp:`sizeof...(<pack_expression>)` shall be assumed=
=2E If either value is negative, it shall first be added to :cpp:`sizeof.=
=2E.(<pack_expression>)`. Each value shall then be clamped to the range [=
\ :cpp:`0`, :cpp:`sizeof...(<pack_expression>)`]. If, after normalization=
and clamping, the upper index is less than the lower index, an empty par=
ameter pack shall be yielded. (Note that this means that a variable slice=
is never ill-formed due to out of bounds index values.)
This can be represented in pseudo-code::
// let [lower:upper](pack) represent the complete slicing expression
size =3D sizeof...(pack);
if lower is unspecified:
lower =3D 0;
if upper is unspecified:
upper =3D size;
if lower < 0:
lower =3D size + lower;
if upper < 0:
upper =3D size + upper;
lower =3D bound(0, lower, size);
upper =3D bound(0, upper, size);
for (index =3D lower; index < upper; ++index)
yield [index]pack;
Note that the expressions :cpp:`[:]pack` and :cpp:`pack` are equivalent; =
that is, a slicing expression which uses the defaults for both the lower =
and upper indices shall produce the same parameter pack.
Generalized Unpacking
---------------------
By presenting slicing first, we may consider generalized unpacking to be =
an extension of parameter pack operations to work on product types. Speci=
fically, we propose that the above described slicing operator and :cpp:`s=
izeof...` be extended to accept product types as well as parameter packs.=
When used on a product type, the type is "unpacked" into a parameter pac=
k.
For example, given a product type :cpp:`t` of size 3, :cpp:`sizeof...(t)`=
would be well formed and equal to 3, and the expression :cpp:`[:]t` woul=
d expand to a parameter pack equivalent to :cpp:`get<0>(t), get<1>(t), ge=
t<2>(t)`. (While we use :cpp:`get<N>` here for illustrative purposes, thi=
s proposal would reflect any changes made to product type access.)
Accordingly, :cpp:`[expr1]expr2` would be equivalent to :cpp:`get<expr1>(=
expr2)`; that is, a single value rather than a parameter pack.
Implementing this is straight forward; if a slicing operation or :cpp:`si=
zeof...` is used on an expression which is not a parameter pack, rather t=
han being an error, the compiler shall attempt to proceed as if the expre=
ssion produces a product type. (If this attempt also fails, then an error=
is raised, as usual.)
This makes possible uses like the following, which are not readily accomp=
lished using library-only solutions:
=2E. code:: c++
// let a1..a9 be single values
// let t1, t2 be tuple-like
auto x =3D SomeType(a1, [:]t1..., [3:]t2..., a2);
foo([1:]t1..., a3, [0]t1);
// let v be a vector-like type of T that may or may not be an array, e.=
g.:
// std::array<int, N>
// Eigen::Vector3d
// QPoint
// struct Point { int x, y; }
auto manhattan_distance d =3D std::abs([:]v) + ...;
auto dot =3D [:]v * ...;
Note also an important implication of both the above code and many of the=
examples to follow; namely, that we assign the slicing/unpacking operato=
r (prefix :cpp:`operator[]`) higher precedence than fold operator (postfi=
x :cpp:`operator...`).
Additional Examples
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
Heads and Tails
---------------
It should be obvious that this solves problems alluded to by P0478_:
=2E. code:: c++
// Ugly and broken
void signal(auto... args, auto last)
{
// pass first 5 arguments to callback; ignore the rest
if constexpr (sizeof...(args) > 5)
return signal(args...);
else if constexpr (sizeof...(args) =3D=3D 4)
callback(args..., last);
else
callback(args...);
}
// Enormously better
void signal(auto... args)
{
// pass first 5 arguments to callback; ignore the rest
callback([:5]args...);
}
Note also that the above "ugly" version of the function has several issue=
s (which we have copied from its specification in P0478_\ R0):
- It cannot be invoked with zero arguments.
- When invoked recursively, there is a spurious :cpp:`return` statement.
- If fewer than 5 arguments are supplied to :cpp:`signal`, the last argum=
ent is unintentionally dropped.
The last point in particular is subtle and difficult to reason about, thu=
s providing an excellent illustration of why needing to write code like t=
his is bad. The version using our proposed feature is enormously cleaner =
and far easier to understand, and significantly reduces the chances of ma=
king such mistakes in the implementation. In addition, recursion is elimi=
nated entirely (which, given that the example is accepting parameters by-=
value, could be critically important if some arguments have non-trivial c=
opy constructors).
We can also improve the second example:
=2E. code:: c++
// Mostly okay
auto alternate_tuple(auto first, auto... middle, auto last)
{
if constexpr (sizeof...(items) <=3D 2)
return std::tuple(first, last, middle...);
else
return std::tuple_cat(std::tuple(first, last),
alternate_tuple(middle...));
}
// Better
auto alternate_tuple(auto... items)
{
if constexpr (sizeof...(items) < 3)
return std::tuple{items...};
else
return std::tuple{[0]items, [-1]items,
[:]alternate_tuple([1:-1]items...)...};
}
As with the previous example, our version solves a boundary case (in this=
instance, when fewer than two items are given) that is not handled by th=
e version given in P0478_. In particular, without slicing, one must imple=
ment an overload to handle such boundary cases, potentially resulting in =
duplicated code and the attendant increase in maintenance burden. With sl=
icing, we can trivially handle such boundary cases in the same function.
Divide-and-Conquer
------------------
The ability to slice parameter packs makes it possible to implement binar=
y divide-and-conqueror algorithms on parameter packs, which would be diff=
icult or impossible to achieve otherwise. Consider this example which sel=
ects the "best" element in a parameter pack:
=2E. code:: c++
auto best(auto const& first, auto const&... remainder)
{
if constexpr (sizeof...(remainder) =3D=3D 0)
return first;
else
return better_of(first, best(remainder...);
}
While this example is overly simplified, what if it was significantly mor=
e efficient if the function could be written to require only ``O(log N)``=
recursion rather than ``O(N)`` recursion? With slicing, this can be acco=
mplished easily:
=2E. code:: c++
auto best(auto const&... args)
{
constexpr auto k =3D sizeof...(args);
if constexpr (k =3D=3D 1)
return [0]args;
else
return better_of(best([:k/2]args...), best([k/2:]args...));
}
Note also that the above code no longer needs to accept the first argumen=
t separately.
Unpacking and Fold Expressions
------------------------------
Let's consider now some additional examples of how generalized unpacking =
allows us to write fold expressions on the elements of product types:
=2E. code:: c++
std::tuple<int> t1 { 1, 2, 3 };
std::tuple<int,int> t2 { 4, 5, 6 };
std::tuple<int,int,int> t3 { 7, 8, 9 };
auto tt =3D std::make_tuple(t1, t2, t3); // a tuple of tuples
f([:]tt ...); // f(t1, t2, t3);
f(g([:]tt) ...); // f(g(t1), g(t2), g(t3));
f(g([:]tt ...)); // f(g(t1, t2, t3));
f(g([:][:]tt ...) ...); // ill-formed
f(g([:][:]tt ... ...)); // ill-formed
Note that, due to the precedence we specified, the last two lines are ill=
-formed. In both cases, the second :cpp:`[:]` is redundant, resulting in =
an attempt to apply :cpp:`...` to something which is not a parameter pack=
=2E Note also that a consequence of this precedence is that :cpp:`[:]` ca=
nnot be used as the operator of a fold expression.
This leaves two relatively straight-forward cases that are not addressed =
purely by the proposed feature, but are nevertheless made significantly e=
asier with it:
=2E. code:: c++
// f(g(1,2,3), g(4,5,6), g(7,8,9));
f(std::apply(g, [:]tt)...);
// f(g(1, 2, 3, 4, 5, 6, 7, 8, 9));
f(g([:]std::tuple_cat([:]tt...)...));
f(std::apply(g, [:]tt...));
For the last example, we assume an extension to :cpp:`std::apply` to acce=
pt multiple product types which are "flattened" into the arguments for th=
e specified function. We are not proposing this here, merely showing an e=
xample of how the task could be accomplished.
Although this is effective, at least for the above examples, pack generat=
ors would provide a better solution for this and other more complicated p=
roblems. See `Future Direction`_ for further discussion.
Improving :cpp:`std::apply`
---------------------------
The previous example postulated an extension to :cpp:`std::apply` to acce=
pt multiple product types. While this can of course be achieved already u=
sing :cpp:`std::tuple_cat`, this requires a temporary object and making c=
opies of the values that will eventually be passed as parameters. The pos=
tulated extension should be able to avoid these problems. Using our propo=
sed feature, we can show how this might be implemented:
=2E. code:: c++
namespace std
{
apply_helper<int n>(auto func, auto... args)
{
// n is number of already-unpacked arguments
constexpr auto r =3D sizeof...(args) - n; // remaining tuples
if constexpr (r =3D=3D 0)
return func(args...);
auto&& t =3D [n]args;
auto k =3D sizeof...(t);
return apply_helper<n + k>(func, [:n]args, [:]t..., [n+1:]args);
}
apply(auto func, auto... tuples)
{
return apply_helper<0>(func, tuples);
}
}
Although this is feasible, and would ideally optimize down to a direct ca=
ll of the specified function with all of the tuple values extracted direc=
tly, we would again note that pack generators would offer an even better =
solution to this problem.
Discussion
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
What is a "product type"?
-------------------------
This is an excellent question which deserves its own paper. P0327_ makes =
a good start. When we get to the point of specifying wording, this will n=
eed to be addressed; ideally, this will have happened in parallel. Some "=
working definitions" which may be used to help with consideration of this=
proposal are "types which define :cpp:`tuple_size` and :cpp:`get`", or "=
types to which 'structured binding' / 'assignment unpacking' may be appli=
ed".
Why combine these features?
---------------------------
We prefer to think of this proposal as not two separate features (paramet=
er pack slicing, generalized unpacking), but rather a single feature (pro=
duct type slicing) that works on *both* "concrete" product types and para=
meter packs. Seen in this light, the case for the feature is strengthened=
, as it presents a single syntax that solves multiple problems.
Why choose prefix :cpp:`operator[]`?
------------------------------------
Other alternatives that have been proposed or considered:
- :cpp:`t.N`, :cpp:`t~N`
While these work for at least the single value case, they are less cond=
ucive to slicing, nor are they as readily extended to generalized unpacki=
ng. The use of an integer in place of an identifier also seems unusual; w=
orse, there is a potential conflict when using a :cpp:`constexpr` express=
ion as the index (although this could be solved by enclosing the expressi=
on in ``()``\ s).
- :cpp:`t.[L:U]`, :cpp:`t~(L:U)`
These support slicing, but the syntax is starting to look rather strang=
e.
The exact syntax for these features could be debated. We prefer prefix :c=
pp:`operator[]` because C++ programmers are already familiar with :cpp:`o=
perator[]` as an indexing operator, which is essentially what we are prop=
osing (especially for the single value case), and because the proposed sy=
ntax is very similar to Python, which will already be familiar to some C+=
+ programmers. At the same time, the choice of a prefix as opposed to pos=
tfix syntax makes it clear that the slicing operation |--| which we like =
to think of as *compile-time indexing* |--| is different from the usual *=
run-time indexing*.
Does this make :cpp:`std::apply` (and :cpp:`std::make_from_tuple`) obsole=
te?
-------------------------------------------------------------------------=
---
No. There will almost certainly remain cases where :cpp:`std::apply` and/=
or :cpp:`std::make_from_tuple` are useful; for example, when using the op=
eration as a functor that gets passed as an argument, or when expansions =
are nested. In fact, we use :cpp:`std::apply` in at least one of the prec=
eding examples *in conjunction with* our proposed feature.
That said, we do expect that *most* uses of :cpp:`std::apply` and :cpp:`s=
td::make_from_tuple` can be replaced with the use of this feature.
What about ambiguity with lambda captures?
------------------------------------------
A lambda capture is required to be a variable in the current scope. As su=
ch, the compiler can determine if a :cpp:`[` starts a lambda capture or a=
slicing expression by parsing at most three additional tokens. If the fi=
rst token following the :cpp:`[` is not a variable eligible for lambda ca=
pture (for example, an integer literal), then the :cpp:`[` starts a slici=
ng expression. If the first token matches an in-scope (and :cpp:`constexp=
r`) variable name, and the second token is not a :cpp:`,`, then the :cpp:=
`[` starts a slicing expression. In all other cases, the :cpp:`[` shall b=
e taken to start a lambda capture, as in current C++. (If the first token=
is :cpp:`&`, the preceding rules may be applied with the token counts sh=
ifted by 1. However, this assumes that there exists a case where unary :c=
pp:`operator&` is :cpp:`constexpr`. This may not be reasonable, in which =
case :cpp:`[&` would always indicate a lambda capture, and at most only t=
wo tokens following :cpp:`[` must be parsed.)
Consider the following example:
=2E. code:: c++
constexpr int a =3D ...;
[a]t;
By the above logic, this would be ill-formed. Although a slicing expressi=
on is intended, the compiler would be unable to disambiguate from a lambd=
a until after the :cpp:`]`, and following the above logic, the statement =
is parsed as a lambda. Such an expression calls for disambiguation:
=2E. code:: c++
constexpr int a =3D ...;
[(a)]t;
The addition of parentheses does not change the intended meaning of the s=
tatement, but precludes the statement from being parsed as a lambda captu=
re. We believe that this is an acceptable trade-off to prevent unreasonab=
le complexity in selecting between a slicing expression and a lambda capt=
ure.
Note also:
=2E. code:: c++
template <int n> auto get_and_apply(auto func, auto... items)
{
return func([n]args);
}
Although this example appears at first to be the same as the preceding ex=
ample, :cpp:`n` here is a template parameter and is not eligible for lamb=
da capture, so the expression is parsed as a slicing expression instead (=
as intended). Again, this seems like a reasonable trade-off, but we would=
be amenable to requiring parentheses in all cases where the index-expres=
sion is just an identifier.
An alternative approach, albeit one requiring additional look-ahead, is t=
o consider the token following the closing :cpp:`]`. If the token is not =
:cpp:`(`, then we have a slicing expression. If it is :cpp:`(` and the ne=
xt token is *not* a type name, then we have a slicing expression. Otherwi=
se, we have a lambda capture. This may be more robust, at the cost of bei=
ng more difficult to implement in compilers.
Why choose trailing index?
--------------------------
The choice of the second value as a non-inclusive index, rather than a co=
unt, was made for consistency with existing convention (specifically, Pyt=
hon), because it is consistent with counting indices given a lower and up=
per bound, and because it simplifies the computation of the upper index w=
hen a negative value is given.
It is also worth noting that more complicated index expressions may be us=
ed to obtain a first-and-count slice using lower-until-upper notation or =
vice versa. More importantly, however, a first-and-count slice may be obt=
ained like :cpp:`[:count][first:]pack`, but obtaining a lower-until-upper=
slice with first-and-count syntax is more verbose.
Why extend :cpp:`sizeof...`?
----------------------------
The short answer is "symmetry". It seems logical to us that if slicing wo=
rks on both parameter packs and "concrete" product types that :cpp:`sizeo=
f...` should do likewise. However, this modification could be dropped wit=
hout significantly harming the proposal.
What alternatives were considered?
----------------------------------
There are at least three possible alternatives that could provide feature=
s similar to generalized unpacking, as proposed here. The first alternati=
ve is first class support for multiple return values, where such are trea=
ted as parameter packs. The second is modifying structured binding (which=
we prefer to call "assignment unpacking", for symmetry with "generalized=
unpacking") to support specifying a parameter pack as one of the unpacke=
d values. The third is to introduce parameter pack generators.
- First class support for multiple return values (which is effectively pr=
oposed by P0341_) is an ambitious feature with assorted difficulties (see=
next question). Moreover, if FIXME_ is accepted, the need for true first=
class multiple return values would be significantly lessened.
- Modifying assignment unpacking (e.g. :cpp:`auto&& [x, p..., y] =3D t;`)=
is likewise a language change of similar caliber to what we propose, wit=
h the added drawback of requiring additional declarations for many use ca=
ses.
- Parameter pack generation is interesting (in fact, we would like to see=
parameter pack generation *in addition* to this proposal), but still req=
uires the ability to extract a single element from a pack.
All of these would require greater verbosity for even simple use cases.
We believe that our proposal is the best solution, as it solves a crucial=
need not addressed by these alternatives (extracting a single value from=
a parameter pack) and further leverages that syntax to maximum versatili=
ty with minimal overhead compared to the minimum possible functionality.
How does this relate to P0341_?
-------------------------------
We would be remiss to not discuss P0341_, especially in light of our prop=
osed generalized unpacking feature. Leaving aside various concerns as far=
as returning parameter packs (which are also discussed in FIXME_), gener=
alized unpacking obviates a major use case for some of the features propo=
sed by P0341_. In particular, P0341_ gives this example:
=2E. code:: c++
<double, double> calculateTargetCoordinates();
double distanceFromMe(double x, double y);
void launch() {
if(distanceFromMe(calculateTargetCoordinates()...))
getOuttaHere();
}
The utility of being able to invoke the postulated :cpp:`distanceFromMe` =
function taking two parameters is obvious. However, the solution proposed=
by P0341_ is strictly limited in that it requires that the function prov=
iding the input values |--| :cpp:`calculateTargetCoordinates` |--| must p=
rovide them as a parameter pack. Moreover, it is not obvious at the point=
of use that :cpp:`calculateTargetCoordinates` returns a parameter pack r=
ather than a regular type.
Generalized unpacking provides a much better solution:
=2E. code:: c++
std::tuple<double, double> calculateTargetCoordinates();
double distanceFromMe(double x, double y);
void launch() {
if(distanceFromMe([:]calculateTargetCoordinates()...))
getOuttaHere();
}
The return type of :cpp:`calculateTargetCoordinates` is a regular type, a=
nd we can call :cpp:`distanceFromMe` on any product type value that can c=
onvert (or be sliced) to a pair of :cpp:`double`s.
Future Direction
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
This feature is not intended to solve all cases of value sequence composi=
tions and decompositions by itself. We specifically are not attempting to=
provide a language mechanism for reversing a value sequence, selecting i=
ndices (e.g. every other item) from a value sequence, or interleaving val=
ue sequences. We believe that there is significant room for library featu=
res to bring added value to this area. Such features would likely leverag=
e this feature under the covers. (Parameter pack generation, which as not=
ed is a feature we would like to see, almost certainly would use at least=
single-value indexing into parameter packs.)
Acknowledgments
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
We wish to thank everyone on the ``std-proposals`` forum that has contrib=
uted over the long period for which this has been marinating.
References
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
=2E. _N4235: http://wg21.link/n4235
* N4235_ Selecting from Parameter Packs
http://wg21.link/n4235
=2E. _P0222: http://wg21.link/p0222
* P0222_ Allowing Anonymous Structs as Return Values
http://wg21.link/p0222
=2E. _P0311: http://wg21.link/p0311
* P0311_ A Unified Vision for Manipulating Tuple-like Objects
http://wg21.link/p0311
=2E. _P0327: http://wg21.link/p0327
* P0327_ Product Types Access
http://wg21.link/p0327
=2E. _P0341: http://wg21.link/p0341
* P0341_ Parameter Packs Outside of Templates
http://wg21.link/p0341
=2E. _P0478: http://wg21.link/p0478
* P0478_ Template argument deduction for non-terminal function parameter =
packs
http://wg21.link/p0478
=2E. FIXME link to p0222/p0224 successor
=2E. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..=
.. ..
=2E. |--| unicode:: U+02014 .. em dash
=2E. kate: hl reStructuredText
--------------050205010902060401060803
Content-Type: text/html; charset=UTF-8;
name="dxxxx-generalized-unpacking.html"
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
filename="dxxxx-generalized-unpacking.html"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--------------050205010902060401060803--
.
Author: "T. C." <rs2740@gmail.com>
Date: Mon, 19 Dec 2016 12:34:37 -0800 (PST)
Raw View
------=_Part_469_395680766.1482179677679
Content-Type: multipart/alternative;
boundary="----=_Part_470_887569681.1482179677679"
------=_Part_470_887569681.1482179677679
Content-Type: text/plain; charset=UTF-8
Only skimmed very quickly; I may have more comments later.
1. The first line of "Parameter Pack Slicing" doesn't seem to be formatted
correctly: note all the backticks.
2. I don't buy the argument in "improving std::apply" about tuple_cat. You
can just make a helper to create a tuple of references from a plain tuple
and use tuple_cat on the result of that. Also, the code fragment in that
section makes plenty of copies, ironically, and its broken syntax is also
distracting.
--
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/97caa1df-7738-45ce-9340-cefb6c662acb%40isocpp.org.
------=_Part_470_887569681.1482179677679
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">Only skimmed very quickly; I may have more comments later.=
<br><br><div>1. The first line of "Parameter Pack Slicing" doesn&=
#39;t seem to be formatted correctly: note all the backticks.</div><div><br=
></div><div>2. I don't buy the argument in "improving std::apply&q=
uot; about tuple_cat. You can just make a helper to create a tuple of refer=
ences from a plain tuple and use tuple_cat on the result of that. Also,=C2=
=A0the code fragment in that section makes plenty of copies, ironically, an=
d its broken syntax is also distracting.</div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" 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/97caa1df-7738-45ce-9340-cefb6c662acb%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/97caa1df-7738-45ce-9340-cefb6c662acb=
%40isocpp.org</a>.<br />
------=_Part_470_887569681.1482179677679--
------=_Part_469_395680766.1482179677679--
.
Author: Matthew Woehlke <mwoehlke.floss@gmail.com>
Date: Mon, 19 Dec 2016 16:11:31 -0500
Raw View
On 2016-12-19 15:34, T. C. wrote:
> 1. The first line of "Parameter Pack Slicing" doesn't seem to be formatted
> correctly: note all the backticks.
It's correct, as can be seen in the HTML. Double ``s are markup for
literal text; the unbalanced `s appear literally in the output. Here's
the output (sans rich text):
... operator, `[` <slicing_expression> `]`, which ...
... one of <index> or [<index>] `:` [<index>], where ...
The intent is that ``-marked text denotes a literal token. (This is
somewhat important when []s are being thrown around both as literal
tokens and this-is-optional indicators... Unfortunately, it is not easy
in reST to have text that is both bold and literal.)
> 2. I don't buy the argument in "improving std::apply" about tuple_cat. You
> can just make a helper to create a tuple of references from a plain tuple
> and use tuple_cat on the result of that.
....but you still have to build that new tuple, and it sounds like your
invocation is still going to be non-trivially more complicated that the
postulated std::apply taking multiple tuples. (Anyway, this is not part
of the proposal, just an example of "stuff you can do with this feature".)
> Also, the code fragment in that section makes plenty of copies,
> ironically, and its broken syntax is also distracting.
Which syntax is broken?
--
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.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/58584D03.9040902%40gmail.com.
.
Author: "T. C." <rs2740@gmail.com>
Date: Mon, 19 Dec 2016 14:26:44 -0800 (PST)
Raw View
------=_Part_1267_1646192655.1482186404120
Content-Type: multipart/alternative;
boundary="----=_Part_1268_814947656.1482186404120"
------=_Part_1268_814947656.1482186404120
Content-Type: text/plain; charset=UTF-8
On Monday, December 19, 2016 at 4:11:33 PM UTC-5, Matthew Woehlke wrote:
>
> On 2016-12-19 15:34, T. C. wrote:
> > 1. The first line of "Parameter Pack Slicing" doesn't seem to be
> formatted
> > correctly: note all the backticks.
>
> It's correct, as can be seen in the HTML. Double ``s are markup for
> literal text; the unbalanced `s appear literally in the output. Here's
> the output (sans rich text):
>
> ... operator, `[` <slicing_expression> `]`, which ...
> ... one of <index> or [<index>] `:` [<index>], where ...
>
> The intent is that ``-marked text denotes a literal token. (This is
> somewhat important when []s are being thrown around both as literal
> tokens and this-is-optional indicators... Unfortunately, it is not easy
> in reST to have text that is both bold and literal.)
>
I see (I thought that the backticks were remnants from the source). You
might want to consider the way the standard's grammar indicates optional
elements instead (subscript "opt")
>
> > 2. I don't buy the argument in "improving std::apply" about tuple_cat.
> You
> > can just make a helper to create a tuple of references from a plain
> tuple
> > and use tuple_cat on the result of that.
>
> ...but you still have to build that new tuple, and it sounds like your
> invocation is still going to be non-trivially more complicated that the
> postulated std::apply taking multiple tuples. (Anyway, this is not part
> of the proposal, just an example of "stuff you can do with this feature".)
>
>
The point is that extending std::apply to take multiple tuples doesn't
require this feature. Such a thing can easily be implemented using the
current tools:
template<class Tuple, size_t... Is>
auto t2r(Tuple&& tuple, std::index_sequence<Is...>) {
return
std::forward_as_tuple(std::get<Is>(std::forward<Tuple>(tuple))...);
}
template<class Tuple>
auto t2r(Tuple&& tuple) {
return t2r(std::forward<Tuple>(tuple),
std::make_index_sequence<std::tuple_size_v<std::decay_t<Tuple>>>());
}
template<class F, class...Tuples>
decltype(auto) multi_apply(F&&f, Tuples&&... tuples) {
return apply(std::forward<F>(f),
std::tuple_cat(t2r(std::forward<Tuples>(tuples))...));
}
with no copying involved. I simply don't think this is a good example to
showcase your feature.
> Also, the code fragment in that section makes plenty of copies,
> > ironically, and its broken syntax is also distracting.
>
> Which syntax is broken?
>
Lack of return type on apply and apply_helper. Template parameter list
after the declarator-id for the latter.
> --
> 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.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/90086f7c-c452-4f76-8072-1e7df36c38aa%40isocpp.org.
------=_Part_1268_814947656.1482186404120
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><br><br>On Monday, December 19, 2016 at 4:11:33 PM UTC-5, =
Matthew Woehlke wrote:<blockquote class=3D"gmail_quote" style=3D"margin: 0;=
margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;">On 2016-=
12-19 15:34, T. C. wrote:
<br>> 1. The first line of "Parameter Pack Slicing" doesn'=
t seem to be formatted=20
<br>> correctly: note all the backticks.
<br>
<br>It's correct, as can be seen in the HTML. Double ``s are markup for
<br>literal text; the unbalanced `s appear literally in the output. Here=
9;s
<br>the output (sans rich text):
<br>
<br>=C2=A0 ... operator, `[` <slicing_expression> `]`, which ...
<br>=C2=A0 ... one of <index> or [<index>] `:` [<index>],=
where ...
<br>
<br>The intent is that ``-marked text denotes a literal token. (This is
<br>somewhat important when []s are being thrown around both as literal
<br>tokens and this-is-optional indicators... Unfortunately, it is not easy
<br>in reST to have text that is both bold and literal.)
<br></blockquote><div><br></div><div>I see (I thought that the backticks we=
re remnants from the source). You might want to consider the way the standa=
rd's grammar indicates optional elements instead (subscript "opt&q=
uot;)</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;">
<br>> 2. I don't buy the argument in "improving std::apply"=
; about tuple_cat. You=20
<br>> can just make a helper to create a tuple of references from a plai=
n tuple=20
<br>> and use tuple_cat on the result of that.
<br>
<br>...but you still have to build that new tuple, and it sounds like your
<br>invocation is still going to be non-trivially more complicated that the
<br>postulated std::apply taking multiple tuples. (Anyway, this is not part
<br>of the proposal, just an example of "stuff you can do with this fe=
ature".)
<br>
<br></blockquote><div><br></div><div>The point is that extending=C2=A0std::=
apply=C2=A0to take multiple tuples doesn't require this feature. Such a=
thing can easily be implemented using the current tools:</div><div><br></d=
iv><div>template<class Tuple, size_t... Is></div><div>auto t2r(Tuple&=
amp;& tuple, std::index_sequence<Is...>) {=C2=A0</div><div>=C2=A0=
=C2=A0 return std::forward_as_tuple(std::get<Is>(std::forward<Tup=
le>(tuple))...);</div><div>}</div><div><br></div><div><div>template<c=
lass Tuple></div><div>auto t2r(Tuple&& tuple) {=C2=A0</div><div>=
=C2=A0 =C2=A0 return t2r(std::forward<Tuple>(tuple), std::make_index_=
sequence<std::tuple_size_v<std::decay_t<Tuple>>>());=C2=
=A0</div><div>}</div></div><div><br></div><div>template<class F, class..=
..Tuples></div><div>decltype(auto) multi_apply(F&&f, Tuples&&=
amp;... tuples) {</div><div>=C2=A0 =C2=A0 return apply(std::forward<F>=
;(f), std::tuple_cat(t2r(std::forward<Tuples>(tuples))...));=C2=A0</d=
iv><div>}</div><div><br></div><div>with no copying involved. I simply don&#=
39;t think this is a good example to showcase your feature.</div><div><br><=
/div><blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8e=
x;border-left: 1px #ccc solid;padding-left: 1ex;">> Also, the code fragm=
ent in that section makes plenty of copies,
<br>> ironically, and its broken syntax is also distracting.
<br>
<br>Which syntax is broken?
<br></blockquote><div><br></div><div>Lack of return type on apply and apply=
_helper. Template parameter list after the declarator-id for the latter.</d=
iv><div><br></div><blockquote class=3D"gmail_quote" style=3D"margin: 0;marg=
in-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;">
<br>--=20
<br>Matthew
<br></blockquote></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" 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/90086f7c-c452-4f76-8072-1e7df36c38aa%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/90086f7c-c452-4f76-8072-1e7df36c38aa=
%40isocpp.org</a>.<br />
------=_Part_1268_814947656.1482186404120--
------=_Part_1267_1646192655.1482186404120--
.
Author: "Vicente J. Botet Escriba" <vicente.botet@wanadoo.fr>
Date: Tue, 20 Dec 2016 01:16:05 +0100
Raw View
This is a multi-part message in MIME format.
--------------7F9753D8486B244CE2C5C482
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: quoted-printable
Le 19/12/2016 =C3=A0 20:19, Matthew Woehlke a =C3=A9crit :
> I've talked about this on numerous occasions... here at last is a formal
> paper. Comments appreciated!
>
> I'd also appreciate if anyone has good, concrete examples for why
> extracting single elements from a pack is useful.
>
> Short Summary:
> --------------
>
> Add a syntax for slicing parameter packs. Extend this syntax to also
> work on product types. Gain ability to convert a product type to a
> parameter pack in the process.
>
> Longer summary:
> ---------------
>
> This is a two-part proposal.
>
> The first part proposes to add parameter pack slicing, of the form
> `[I]pack` or `[L:U]pack`. The first syntax says to take the `I`th
> element of the pack, and produces a single value. The second syntax says
> to take the elements of the pack with indices from `L` (inclusive) until
> `U` (exclusive), and produces a modified pack. Either bound may be
> omitted, and negative indices may be used to indicate 'count from end'
> semantics. Accordingly, `[:]pack` is a no-op. (Slicing has higher
> precedence than fold expansion. Refer to the paper for more specifics.)
>
> The second part proposes that parameter pack operations, particularly
> slicing (as in the first part), but also (optionally) `sizeof...`,
> should also work on product types as well as packs. Critically, this
> means that the following would now be semantically equivalent:
>
> std::apply(foo, pt);
> foo([:]pt...);
>
> Please refer to the paper for motivating examples.
>
> Postscript:
> -----------
>
> Some links in this are known to be broken, as they are intended to refer
> to my other draft proposal re: allowing types to be defined in return
> type specifications. See also
> https://groups.google.com/a/isocpp.org/forum/#!topic/std-proposals/y7dyHc=
D_BKA.
>
Hi,
glad to see such a proposal.
I'm not against redefining sizeof for product types, but it will be=20
worth mentioning the syntax is possible sizeof([:]t...) without the=20
redefinition.
The <double, double> returned in
<double, double> calculateTargetCoordinates();
is not a parameter pack but a pack type as defined in P0341. This is of=20
course something new.
I like the [start:stop] operator on parameter packs and product types. I=20
prefer [:] to the user defined operator... proposed in P0341.
Pack types as defined in P0341 should accept this slice operator (we=20
shoild consider Pack types as product types). I'm not sure we will need=20
that Pack types provide directly the expansion operator....
Have you considered strides [start:stop:step]? reverted slices=20
[start:stop:-1]? (see=20
https://docs.python.org/2.3/whatsnew/section-slices.html)
The main difference between the proposed slice operator and python=20
slices is that the result is not a type, but a parameter pack, that can=20
not be on the LHS of an assignment. Have you considered this possibility?
Vicente
--=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.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/57cfa4b1-679a-76e8-e9e5-1a69facf259d%40wanadoo.f=
r.
--------------7F9753D8486B244CE2C5C482
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
<html>
<head>
<meta content=3D"text/html; charset=3Dutf-8" http-equiv=3D"Content-Type=
">
</head>
<body bgcolor=3D"#FFFFFF" text=3D"#000000">
<div class=3D"moz-cite-prefix">Le 19/12/2016 =C3=A0 20:19, Matthew Woeh=
lke
a =C3=A9crit=C2=A0:<br>
</div>
<blockquote cite=3D"mid:585832D9.7010208@gmail.com" type=3D"cite">
<pre wrap=3D"">I've talked about this on numerous occasions... here a=
t last is a formal
paper. Comments appreciated!
I'd also appreciate if anyone has good, concrete examples for why
extracting single elements from a pack is useful.
Short Summary:
--------------
Add a syntax for slicing parameter packs. Extend this syntax to also
work on product types. Gain ability to convert a product type to a
parameter pack in the process.
Longer summary:
---------------
This is a two-part proposal.
The first part proposes to add parameter pack slicing, of the form
`[I]pack` or `[L:U]pack`. The first syntax says to take the `I`th
element of the pack, and produces a single value. The second syntax says
to take the elements of the pack with indices from `L` (inclusive) until
`U` (exclusive), and produces a modified pack. Either bound may be
omitted, and negative indices may be used to indicate 'count from end'
semantics. Accordingly, `[:]pack` is a no-op. (Slicing has higher
precedence than fold expansion. Refer to the paper for more specifics.)
The second part proposes that parameter pack operations, particularly
slicing (as in the first part), but also (optionally) `sizeof...`,
should also work on product types as well as packs. Critically, this
means that the following would now be semantically equivalent:
std::apply(foo, pt);
foo([:]pt...);
Please refer to the paper for motivating examples.
Postscript:
-----------
Some links in this are known to be broken, as they are intended to refer
to my other draft proposal re: allowing types to be defined in return
type specifications. See also
<a class=3D"moz-txt-link-freetext" href=3D"https://groups.google.com/a/isoc=
pp.org/forum/#!topic/std-proposals/y7dyHcD_BKA">https://groups.google.com/a=
/isocpp.org/forum/#!topic/std-proposals/y7dyHcD_BKA</a>.
</pre>
</blockquote>
<p>Hi,</p>
<p>glad to see such a proposal.</p>
<p>I'm not against redefining sizeof for product types, but it will
be worth mentioning the syntax is possible sizeof([:]t...) without
the redefinition.<br>
<br>
The <double, double> returned in<br>
<br>
=C2=A0=C2=A0=C2=A0 <double, double> calculateTargetCoordinates(=
);<br>
<br>
is not a parameter pack but a pack type as defined in P0341. This
is of course something new.<br>
</p>
<p>I like the [start:stop] operator on parameter packs and product
types. I prefer [:] to the user defined operator... proposed in
P0341. <br>
<br>
Pack types as defined in P0341 should accept this slice operator
(we shoild consider Pack types as product types). I'm not sure we
will need that Pack types provide directly the expansion
operator....<span class=3D"punctuation"><br>
</span></p>
<p><span class=3D"punctuation">Have you considered strides </span><span
class=3D"punctuation">[start:stop:step]? reverted slices </span><sp=
an
class=3D"punctuation"><span class=3D"punctuation">[start:stop:-1]</=
span>?
(see <a class=3D"moz-txt-link-freetext" href=3D"https://docs.python=
..org/2.3/whatsnew/section-slices.html">https://docs.python.org/2.3/whatsnew=
/section-slices.html</a>)<br>
</span></p>
<p><span class=3D"punctuation">The main difference between the
proposed slice operator and python slices is that the result is
not a type, but a parameter pack, that can not be on the LHS of
an assignment. Have you considered this possibility?<br>
</span></p>
<p><span class=3D"punctuation">Vicente<br>
</span></p>
</body>
</html>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" 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/57cfa4b1-679a-76e8-e9e5-1a69facf259d%=
40wanadoo.fr?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/57cfa4b1-679a-76e8-e9e5-1a69facf259d=
%40wanadoo.fr</a>.<br />
--------------7F9753D8486B244CE2C5C482--
.
Author: Nicol Bolas <jmckesson@gmail.com>
Date: Mon, 19 Dec 2016 19:33:04 -0800 (PST)
Raw View
------=_Part_484_1570589466.1482204784343
Content-Type: multipart/alternative;
boundary="----=_Part_485_638172296.1482204784344"
------=_Part_485_638172296.1482204784344
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
On Monday, December 19, 2016 at 7:16:08 PM UTC-5, Vicente J. Botet Escriba=
=20
wrote:
>
> Le 19/12/2016 =C3=A0 20:19, Matthew Woehlke a =C3=A9crit :
>
> I've talked about this on numerous occasions... here at last is a formal
> paper. Comments appreciated!
>
> I'd also appreciate if anyone has good, concrete examples for why
> extracting single elements from a pack is useful.
>
> Short Summary:
> --------------
>
> Add a syntax for slicing parameter packs. Extend this syntax to also
> work on product types. Gain ability to convert a product type to a
> parameter pack in the process.
>
> Longer summary:
> ---------------
>
> This is a two-part proposal.
>
> The first part proposes to add parameter pack slicing, of the form
> `[I]pack` or `[L:U]pack`. The first syntax says to take the `I`th
> element of the pack, and produces a single value. The second syntax says
> to take the elements of the pack with indices from `L` (inclusive) until
> `U` (exclusive), and produces a modified pack. Either bound may be
> omitted, and negative indices may be used to indicate 'count from end'
> semantics. Accordingly, `[:]pack` is a no-op. (Slicing has higher
> precedence than fold expansion. Refer to the paper for more specifics.)
>
> The second part proposes that parameter pack operations, particularly
> slicing (as in the first part), but also (optionally) `sizeof...`,
> should also work on product types as well as packs. Critically, this
> means that the following would now be semantically equivalent:
>
> std::apply(foo, pt);
> foo([:]pt...);
>
> Please refer to the paper for motivating examples.
>
> Postscript:
> -----------
>
> Some links in this are known to be broken, as they are intended to refer
> to my other draft proposal re: allowing types to be defined in return
> type specifications. See alsohttps://groups.google.com/a/isocpp.org/forum=
/#!topic/std-proposals/y7dyHcD_BKA.
>
>
> Hi,
>
> glad to see such a proposal.
>
> I'm not against redefining sizeof for product types, but it will be worth=
=20
> mentioning the syntax is possible sizeof([:]t...) without the redefinitio=
n.
>
I think the syntax would be `sizeof...([:]t)`. After all, `[:]t` is a pack,=
=20
and `sizeof...` returns the number of elements in the pack. No need to=20
redefine anything.
=20
> The main difference between the proposed slice operator and python slices=
=20
> is that the result is not a type, but a parameter pack, that can not be o=
n=20
> the LHS of an assignment. Have you considered this possibility?
>
That can easily be handled by unpacking it into a tuple of references,=20
which can be assigned to.
--=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.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/1cf9797b-6671-465a-999d-a5c62c92c038%40isocpp.or=
g.
------=_Part_485_638172296.1482204784344
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><br><br>On Monday, December 19, 2016 at 7:16:08 PM UTC-5, =
Vicente J. Botet Escriba wrote:<blockquote class=3D"gmail_quote" style=3D"m=
argin: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"=
>
=20
=20
=20
<div bgcolor=3D"#FFFFFF" text=3D"#000000">
<div>Le 19/12/2016 =C3=A0 20:19, Matthew Woehlke
a =C3=A9crit=C2=A0:<br>
</div>
<blockquote type=3D"cite">
<pre>I've talked about this on numerous occasions... here at last=
is a formal
paper. Comments appreciated!
I'd also appreciate if anyone has good, concrete examples for why
extracting single elements from a pack is useful.
Short Summary:
--------------
Add a syntax for slicing parameter packs. Extend this syntax to also
work on product types. Gain ability to convert a product type to a
parameter pack in the process.
Longer summary:
---------------
This is a two-part proposal.
The first part proposes to add parameter pack slicing, of the form
`[I]pack` or `[L:U]pack`. The first syntax says to take the `I`th
element of the pack, and produces a single value. The second syntax says
to take the elements of the pack with indices from `L` (inclusive) until
`U` (exclusive), and produces a modified pack. Either bound may be
omitted, and negative indices may be used to indicate 'count from end&#=
39;
semantics. Accordingly, `[:]pack` is a no-op. (Slicing has higher
precedence than fold expansion. Refer to the paper for more specifics.)
The second part proposes that parameter pack operations, particularly
slicing (as in the first part), but also (optionally) `sizeof...`,
should also work on product types as well as packs. Critically, this
means that the following would now be semantically equivalent:
std::apply(foo, pt);
foo([:]pt...);
Please refer to the paper for motivating examples.
Postscript:
-----------
Some links in this are known to be broken, as they are intended to refer
to my other draft proposal re: allowing types to be defined in return
type specifications. See also
<a href=3D"https://groups.google.com/a/isocpp.org/forum/#!topic/std-proposa=
ls/y7dyHcD_BKA" target=3D"_blank" rel=3D"nofollow" onmousedown=3D"this.href=
=3D'https://groups.google.com/a/isocpp.org/forum/#!topic/std-proposals/=
y7dyHcD_BKA';return true;" onclick=3D"this.href=3D'https://groups.g=
oogle.com/a/isocpp.org/forum/#!topic/std-proposals/y7dyHcD_BKA';return =
true;">https://groups.google.com/a/<wbr>isocpp.org/forum/#!topic/std-<wbr>p=
roposals/y7dyHcD_BKA</a>.
</pre>
</blockquote>
<p>Hi,</p>
<p>glad to see such a proposal.</p>
<p>I'm not against redefining sizeof for product types, but it will
be worth mentioning the syntax is possible sizeof([:]t...) without
the redefinition.<br></p></div></blockquote><div><br>I think the synt=
ax would be `sizeof...([:]t)`. After all, `[:]t` is a pack, and `sizeof...`=
returns the number of elements in the pack. No need to redefine anything.<=
/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 bgc=
olor=3D"#FFFFFF" text=3D"#000000"><p><span>
</span></p>
<p><span>The main difference between the
proposed slice operator and python slices is that the result is
not a type, but a parameter pack, that can not be on the LHS of
an assignment. Have you considered this possibility?<br></span></p>=
</div></blockquote><div><br></div>That can easily be handled by unpacking i=
t into a tuple of references, which can be assigned to.<br></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" 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/1cf9797b-6671-465a-999d-a5c62c92c038%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/1cf9797b-6671-465a-999d-a5c62c92c038=
%40isocpp.org</a>.<br />
------=_Part_485_638172296.1482204784344--
------=_Part_484_1570589466.1482204784343--
.
Author: Arthur O'Dwyer <arthur.j.odwyer@gmail.com>
Date: Mon, 19 Dec 2016 20:34:55 -0800 (PST)
Raw View
------=_Part_2948_1778949176.1482208496039
Content-Type: multipart/alternative;
boundary="----=_Part_2949_2028943124.1482208496040"
------=_Part_2949_2028943124.1482208496040
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
On Monday, December 19, 2016 at 7:33:04 PM UTC-8, Nicol Bolas wrote:
>
> On Monday, December 19, 2016 at 7:16:08 PM UTC-5, Vicente J. Botet Escrib=
a=20
> wrote:
>>
>>
>> The main difference between the proposed slice operator and python slice=
s=20
>> is that the result is not a type, but a parameter pack, that can not be =
on=20
>> the LHS of an assignment. Have you considered this possibility?
>>
>
> That can easily be handled by unpacking it into a tuple of references,=20
> which can be assigned to.
>
IIUC (having only skimmed Matthew's paper but debated re packs in this=20
forum often enough ;)) the syntax
template<typename... Ts>
void f(Ts&&... ts)
{
(... , ([1:3]ts =3D 42)); // pack on LHS of assignment, plus a C++17=
=20
fold-expression with operator-comma
}
int main()
{
static int v0,v1,v2,v3,v4;
f(v0,v1,v2,v3,v4);
assert(v0=3D=3D0 && v1=3D=3D42 && v2=3D=3D42 && v3=3D=3D0 && v4=3D=3D0)=
;
}
would indeed fall out naturally. But I believe that what Vicente was=20
referring to is Python's syntax for assigning into a slice of a list:
>>> x =3D [0,1,2,3,4]
>>> x[1:3] =3D [42]
>>> print x
[0, 42, 3, 4]
>>> print 'The above is actually syntactic sugar for:'
The above is actually syntactic sugar for:
>>> x.__setitem__(slice(1,3), [42])
>>> print x
[0, 42, 4]
That is, in Python, an assignment whose LHS is a slice-expression actually=
=20
changes the length of the complete list being sliced! I found some details=
=20
on Python's implementation of slices-on-the-LHS here=20
<https://docs.python.org/2.3/whatsnew/section-slices.html>. AFAIK, it's=20
purely a syntactic-sugar construct =E2=80=94 there is no way to "capture" a=
=20
slice-expression and later use it to mess with the original complete list,=
=20
any more than there's a way to "capture" or "perfect-forward" a=20
heterogeneous braced-initializer-list in C++. Notice that slice is a=20
built-in type (read: standard library type) in Python, but it's just a tag=
=20
type for holding a couple of ints; the actual magic here is happening in x
's __setitem__ method (read: a special member function).
Notice also that Python does not support slice-on-the-LHS for all sliceable=
=20
types. Python's tuples, which are heterogeneous and immutable, do not=20
support slice-on-LHS or even index-on-LHS.
>>> x =3D (0,1,2,3,4)
>>> x[1:3]
(1, 2)
>>> x[0] =3D 42
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> x[1:3] =3D (42,)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
Notice that slicing a tuple gives me a tuple, whereas slicing a list gave=
=20
me a list. This is determined entirely by the behavior of=20
x.__getitem__(slice(1,3)) (read: another special member function). Python=
=20
has a crazy rich=20
<https://docs.python.org/3/reference/datamodel.html#special-method-names>=
=20
set of special member functions: basically any member function whose name=
=20
begins and ends with double-underscore is available to assign special=20
meaning to, and they've been taking advantage of that.
HTH,
Arthur
--=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.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/bfb2424b-f7e0-429b-9f3f-c66ca548e627%40isocpp.or=
g.
------=_Part_2949_2028943124.1482208496040
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">On Monday, December 19, 2016 at 7:33:04 PM UTC-8, Nicol Bo=
las 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 =
Monday, December 19, 2016 at 7:16:08 PM UTC-5, Vicente J. Botet Escriba wro=
te:<blockquote class=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;bo=
rder-left:1px #ccc solid;padding-left:1ex">
=20
=20
=20
<div bgcolor=3D"#FFFFFF" text=3D"#000000">
<div><br></div></div></blockquote><blockquote class=3D"gmail_quote" sty=
le=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-left:1e=
x"><div bgcolor=3D"#FFFFFF" text=3D"#000000"><p><span>
</span></p>
<p><span>The main difference between the
proposed slice operator and python slices is that the result is
not a type, but a parameter pack, that can not be on the LHS of
an assignment. Have you considered this possibility?<br></span></p>=
</div></blockquote><div><br></div>That can easily be handled by unpacking i=
t into a tuple of references, which can be assigned to.<br></div></blockquo=
te><div><br></div><div>IIUC (having only skimmed Matthew's paper but de=
bated re packs in this forum often enough ;)) the syntax</div><div><br></di=
v><div class=3D"prettyprint" style=3D"background-color: rgb(250, 250, 250);=
border: 1px solid rgb(187, 187, 187); word-wrap: break-word;"><code class=
=3D"prettyprint"><div class=3D"subprettyprint"><span style=3D"color: #008;"=
class=3D"styled-by-prettify">template</span><span style=3D"color: #660;" c=
lass=3D"styled-by-prettify"><</span><span style=3D"color: #008;" class=
=3D"styled-by-prettify">typename</span><span style=3D"color: #660;" class=
=3D"styled-by-prettify">...</span><span style=3D"color: #000;" class=3D"sty=
led-by-prettify"> </span><span style=3D"color: #606;" class=3D"styled-by-pr=
ettify">Ts</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: #008;" class=3D"styled-by-prettify">void</span><=
span style=3D"color: #000;" class=3D"styled-by-prettify"> f</span><span sty=
le=3D"color: #660;" class=3D"styled-by-prettify">(</span><span style=3D"col=
or: #606;" class=3D"styled-by-prettify">Ts</span><span style=3D"color: #660=
;" class=3D"styled-by-prettify">&&...</span><span style=3D"color: #=
000;" class=3D"styled-by-prettify"> ts</span><span style=3D"color: #660;" c=
lass=3D"styled-by-prettify">)</span><span style=3D"color: #000;" class=3D"s=
tyled-by-prettify"><br></span><span style=3D"color: #660;" class=3D"styled-=
by-prettify">{</span><span style=3D"color: #000;" class=3D"styled-by-pretti=
fy"><br>=C2=A0 =C2=A0 </span><span style=3D"color: #660;" class=3D"styled-b=
y-prettify">(...</span><span style=3D"color: #000;" class=3D"styled-by-pret=
tify"> </span><span style=3D"color: #660;" class=3D"styled-by-prettify">,</=
span><span style=3D"color: #000;" class=3D"styled-by-prettify"> </span><spa=
n style=3D"color: #660;" class=3D"styled-by-prettify">([</span><span style=
=3D"color: #066;" class=3D"styled-by-prettify">1</span><span style=3D"color=
: #660;" class=3D"styled-by-prettify">:</span><span style=3D"color: #066;" =
class=3D"styled-by-prettify">3</span><span style=3D"color: #660;" class=3D"=
styled-by-prettify">]</span><span style=3D"color: #000;" class=3D"styled-by=
-prettify">ts </span><span style=3D"color: #660;" class=3D"styled-by-pretti=
fy">=3D</span><span style=3D"color: #000;" class=3D"styled-by-prettify"> </=
span><span style=3D"color: #066;" class=3D"styled-by-prettify">42</span><sp=
an style=3D"color: #660;" class=3D"styled-by-prettify">));</span><span styl=
e=3D"color: #000;" class=3D"styled-by-prettify"> =C2=A0</span><span style=
=3D"color: #800;" class=3D"styled-by-prettify">// pack on LHS of assignment=
, plus a C++17 fold-expression with operator-comma</span><span style=3D"col=
or: #000;" class=3D"styled-by-prettify"><br></span><span style=3D"color: #6=
60;" class=3D"styled-by-prettify">}</span><span style=3D"color: #000;" clas=
s=3D"styled-by-prettify"><br><br></span><span style=3D"color: #008;" class=
=3D"styled-by-prettify">int</span><span style=3D"color: #000;" class=3D"sty=
led-by-prettify"> main</span><span style=3D"color: #660;" class=3D"styled-b=
y-prettify">()</span><span style=3D"color: #000;" class=3D"styled-by-pretti=
fy"><br></span><span style=3D"color: #660;" class=3D"styled-by-prettify">{<=
/span><span style=3D"color: #000;" class=3D"styled-by-prettify"><br>=C2=A0 =
=C2=A0 </span><span style=3D"color: #008;" class=3D"styled-by-prettify">sta=
tic</span><span style=3D"color: #000;" class=3D"styled-by-prettify"> </span=
><span style=3D"color: #008;" class=3D"styled-by-prettify">int</span><span =
style=3D"color: #000;" class=3D"styled-by-prettify"> v0</span><span style=
=3D"color: #660;" class=3D"styled-by-prettify">,</span><span style=3D"color=
: #000;" class=3D"styled-by-prettify">v1</span><span style=3D"color: #660;"=
class=3D"styled-by-prettify">,</span><span style=3D"color: #000;" class=3D=
"styled-by-prettify">v2</span><span style=3D"color: #660;" class=3D"styled-=
by-prettify">,</span><span style=3D"color: #000;" class=3D"styled-by-pretti=
fy">v3</span><span style=3D"color: #660;" class=3D"styled-by-prettify">,</s=
pan><span style=3D"color: #000;" class=3D"styled-by-prettify">v4</span><spa=
n style=3D"color: #660;" class=3D"styled-by-prettify">;</span><span style=
=3D"color: #000;" class=3D"styled-by-prettify"><br>=C2=A0 =C2=A0 f</span><s=
pan style=3D"color: #660;" class=3D"styled-by-prettify">(</span><span style=
=3D"color: #000;" class=3D"styled-by-prettify">v0</span><span style=3D"colo=
r: #660;" class=3D"styled-by-prettify">,</span><span style=3D"color: #000;"=
class=3D"styled-by-prettify">v1</span><span style=3D"color: #660;" class=
=3D"styled-by-prettify">,</span><span style=3D"color: #000;" class=3D"style=
d-by-prettify">v2</span><span style=3D"color: #660;" class=3D"styled-by-pre=
ttify">,</span><span style=3D"color: #000;" class=3D"styled-by-prettify">v3=
</span><span style=3D"color: #660;" class=3D"styled-by-prettify">,</span><s=
pan style=3D"color: #000;" class=3D"styled-by-prettify">v4</span><span styl=
e=3D"color: #660;" class=3D"styled-by-prettify">);</span><span style=3D"col=
or: #000;" class=3D"styled-by-prettify"><br>=C2=A0 =C2=A0 </span><span styl=
e=3D"color: #008;" class=3D"styled-by-prettify">assert</span><span style=3D=
"color: #660;" class=3D"styled-by-prettify">(</span><span style=3D"color: #=
000;" class=3D"styled-by-prettify">v0</span><span style=3D"color: #660;" cl=
ass=3D"styled-by-prettify">=3D=3D</span><span style=3D"color: #066;" class=
=3D"styled-by-prettify">0</span><span style=3D"color: #000;" class=3D"style=
d-by-prettify"> </span><span style=3D"color: #660;" class=3D"styled-by-pret=
tify">&&</span><span style=3D"color: #000;" class=3D"styled-by-pret=
tify"> v1</span><span style=3D"color: #660;" class=3D"styled-by-prettify">=
=3D=3D</span><span style=3D"color: #066;" class=3D"styled-by-prettify">42</=
span><span style=3D"color: #000;" class=3D"styled-by-prettify"> </span><spa=
n style=3D"color: #660;" class=3D"styled-by-prettify">&&</span><spa=
n style=3D"color: #000;" class=3D"styled-by-prettify"> v2</span><span style=
=3D"color: #660;" class=3D"styled-by-prettify">=3D=3D</span><span style=3D"=
color: #066;" class=3D"styled-by-prettify">42</span><span style=3D"color: #=
000;" class=3D"styled-by-prettify"> </span><span style=3D"color: #660;" cla=
ss=3D"styled-by-prettify">&&</span><span style=3D"color: #000;" cla=
ss=3D"styled-by-prettify"> v3</span><span style=3D"color: #660;" class=3D"s=
tyled-by-prettify">=3D=3D</span><span style=3D"color: #066;" class=3D"style=
d-by-prettify">0</span><span style=3D"color: #000;" class=3D"styled-by-pret=
tify"> </span><span style=3D"color: #660;" class=3D"styled-by-prettify">&am=
p;&</span><span style=3D"color: #000;" class=3D"styled-by-prettify"> v4=
</span><span style=3D"color: #660;" class=3D"styled-by-prettify">=3D=3D</sp=
an><span style=3D"color: #066;" class=3D"styled-by-prettify">0</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"styled-by-prettify">}</span></div></code></div><div><br><=
/div><div><br></div><div>would indeed fall out naturally. But I believe tha=
t what Vicente was referring to is Python's syntax for assigning into a=
slice of a list:</div><div><br></div><div><p style=3D"line-height: normal;=
font-family: Menlo;"><span style=3D"font-variant-ligatures: no-common-liga=
tures">>>> x =3D [0,1,2,3,4]</span></p>
<p style=3D"line-height: normal; font-family: Menlo;">>>> x[1:3] =
=3D [42]<br></p>
<p style=3D"line-height: normal; font-family: Menlo;"><span style=3D"font-v=
ariant-ligatures: no-common-ligatures">>>> print x</span></p>
<p style=3D"line-height: normal; font-family: Menlo;"><span style=3D"font-v=
ariant-ligatures: no-common-ligatures">[0, 42, 3, 4]</span></p><p style=3D"=
line-height: normal; font-family: Menlo;"><span style=3D"font-variant-ligat=
ures: no-common-ligatures">>>> print 'The above is actually sy=
ntactic sugar for:'</span></p><p style=3D"line-height: normal; font-fam=
ily: Menlo;"><span style=3D"font-variant-ligatures: no-common-ligatures">Th=
e above is actually syntactic sugar for:</span></p><p style=3D"line-height:=
normal; font-family: Menlo;"><span style=3D"font-variant-ligatures: no-com=
mon-ligatures">>>> x.__setitem__(slice(1,3), [42])</span></p><p st=
yle=3D"line-height: normal; font-family: Menlo;"><span style=3D"font-varian=
t-ligatures: no-common-ligatures">>>> print x</span></p><p style=
=3D"line-height: normal; font-family: Menlo;"><span style=3D"font-variant-l=
igatures: no-common-ligatures">
</span></p><p style=3D"line-height: normal; font-family: Menlo;"><span styl=
e=3D"font-variant-ligatures: no-common-ligatures">[0, 42, 4]</span></p><p s=
tyle=3D"line-height: normal; font-family: Menlo;"><span style=3D"font-varia=
nt-ligatures: no-common-ligatures"><br></span></p><p style=3D"line-height: =
normal;"><span style=3D"font-variant-ligatures: no-common-ligatures;"><font=
face=3D"arial, sans-serif">That is, in Python, an assignment whose LHS is =
a slice-expression actually changes the length of the complete list being s=
liced!=C2=A0</font></span>I found some details on Python's implementati=
on of slices-on-the-LHS <a href=3D"https://docs.python.org/2.3/whatsnew/sec=
tion-slices.html">here</a>. AFAIK, it's purely a syntactic-sugar constr=
uct =E2=80=94 there is no way to "capture" a slice-expression and=
later use it to mess with the original complete list, any more than there&=
#39;s a way to "capture" or "perfect-forward" a heterog=
eneous braced-initializer-list in C++. Notice that slice is a built-in type=
(read: standard library type) in Python, but it's just a tag type for =
holding a couple of ints; the actual magic here is happening in=C2=A0<span =
style=3D"font-family: Menlo;">x</span>'s=C2=A0<span style=3D"font-famil=
y: Menlo;">__setitem__</span>=C2=A0method (read: a special member function)=
..</p><p style=3D"line-height: normal;">Notice also that Python does not sup=
port slice-on-the-LHS for all sliceable types. Python's tuples, which a=
re heterogeneous and immutable, do not support slice-on-LHS or even index-o=
n-LHS.</p><p style=3D"line-height: normal;"><br></p><p style=3D"line-height=
: normal; font-family: Menlo;"><span style=3D"font-variant-ligatures: no-co=
mmon-ligatures">>>> x =3D (0,1,2,3,4)</span></p><p style=3D"line-h=
eight: normal; font-family: Menlo;"><span style=3D"font-variant-ligatures: =
no-common-ligatures">>>> x[1:3]</span></p><p style=3D"line-height:=
normal; font-family: Menlo;"><span style=3D"font-variant-ligatures: no-com=
mon-ligatures">(1, 2)</span></p><p style=3D"line-height: normal; font-famil=
y: Menlo;">>>> x[0] =3D 42</p><p style=3D"line-height: normal; fon=
t-family: Menlo;"><span style=3D"font-variant-ligatures: no-common-ligature=
s">Traceback (most recent call last):</span></p><p style=3D"line-height: no=
rmal; font-family: Menlo;"><span style=3D"font-variant-ligatures: no-common=
-ligatures">=C2=A0 File "<stdin>", line 1, in <module>=
;</span></p><p style=3D"line-height: normal; font-family: Menlo;"><span sty=
le=3D"font-variant-ligatures: no-common-ligatures">
</span></p><p style=3D"line-height: normal; font-family: Menlo;"><span styl=
e=3D"font-variant-ligatures: no-common-ligatures">TypeError: 'tuple'=
; object does not support item assignment</span></p><p style=3D"line-height=
: normal; font-family: Menlo;"><span style=3D"font-variant-ligatures: no-co=
mmon-ligatures">>>> x[1:3] =3D (42,)</span></p><p style=3D"line-he=
ight: normal; font-family: Menlo;"><span style=3D"font-variant-ligatures: n=
o-common-ligatures">Traceback (most recent call last):</span></p><p style=
=3D"line-height: normal; font-family: Menlo;"><span style=3D"font-variant-l=
igatures: no-common-ligatures">=C2=A0 File "<stdin>", line =
1, in <module></span></p><p style=3D"line-height: normal; font-family=
: Menlo;">
</p><p style=3D"line-height: normal; font-family: Menlo;"><span style=3D"fo=
nt-variant-ligatures: no-common-ligatures">TypeError: 'tuple' objec=
t does not support item assignment</span></p><p style=3D"line-height: norma=
l;"><span style=3D"font-variant-ligatures: no-common-ligatures;"><font face=
=3D"arial, sans-serif"><br></font></span></p><p style=3D"line-height: norma=
l;"><span style=3D"font-variant-ligatures: no-common-ligatures">Notice that=
slicing a tuple gives me a tuple, whereas slicing a list gave me a list. T=
his is determined entirely by the behavior of=C2=A0</span><span style=3D"fo=
nt-family: Menlo;">x.__getitem__(slice(1,3))</span>=C2=A0(read: another spe=
cial member function). Python has a <a href=3D"https://docs.python.org/3/re=
ference/datamodel.html#special-method-names">crazy rich</a> set of special =
member functions: basically any member function whose name begins and ends =
with double-underscore is available to assign special meaning to, and they&=
#39;ve been taking advantage of that.</p><p style=3D"line-height: normal;">=
<span style=3D"font-variant-ligatures: no-common-ligatures"><font face=3D"a=
rial, sans-serif"><br></font></span></p><p style=3D"line-height: normal;"><=
span style=3D"font-variant-ligatures: no-common-ligatures"><font face=3D"ar=
ial, sans-serif">HTH,</font></span></p><p style=3D"line-height: normal;"><s=
pan style=3D"font-variant-ligatures: no-common-ligatures;"><font face=3D"ar=
ial, sans-serif">Arthur</font></span></p></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" 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/bfb2424b-f7e0-429b-9f3f-c66ca548e627%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/bfb2424b-f7e0-429b-9f3f-c66ca548e627=
%40isocpp.org</a>.<br />
------=_Part_2949_2028943124.1482208496040--
------=_Part_2948_1778949176.1482208496039--
.
Author: Barry Revzin <barry.revzin@gmail.com>
Date: Tue, 20 Dec 2016 06:47:36 -0800 (PST)
Raw View
------=_Part_5733_1354524053.1482245256476
Content-Type: multipart/alternative;
boundary="----=_Part_5734_1991194823.1482245256477"
------=_Part_5734_1991194823.1482245256477
Content-Type: text/plain; charset=UTF-8
>
> IIUC (having only skimmed Matthew's paper but debated re packs in this
> forum often enough ;)) the syntax
>
> template<typename... Ts>
> void f(Ts&&... ts)
> {
> (... , ([1:3]ts = 42)); // pack on LHS of assignment, plus a C++17
> fold-expression with operator-comma
> }
>
> int main()
> {
> static int v0,v1,v2,v3,v4;
> f(v0,v1,v2,v3,v4);
> assert(v0==0 && v1==42 && v2==42 && v3==0 && v4==0);
> }
>
>
> would indeed fall out naturally. But I believe that what Vicente was
> referring to is Python's syntax for assigning into a slice of a list:
>
>
Given what slicing means in Python and what how unpacking typically works
in C++, I think the more natural falling out is:
[1:3]ts#0 = 42;
[1:3]ts#1 = 42;
....
[1:3]ts#N-1 = 42;
not
ts#1 = 42;
ts#2 = 42;
Also, the paper has these two examples:
auto manhattan_distance d = std::abs([:]v) + ...;auto dot = [:]v * ...;
Aside from the extra "d", what are these supposed to do? Both Manhattan
distance and dot product are functions of two vectors, so I don't entirely
understand this example.
--
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/f451bb5f-3575-47e3-b507-677c530f6d01%40isocpp.org.
------=_Part_5734_1991194823.1482245256477
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
<blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;bor=
der-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><div>IIUC (ha=
ving only skimmed Matthew's paper but debated re packs in this forum of=
ten enough ;)) the syntax</div><div><br></div><div style=3D"background-colo=
r:rgb(250,250,250);border:1px solid rgb(187,187,187);word-wrap:break-word">=
<code><div><span style=3D"color:#008">template</span><span style=3D"color:#=
660"><</span><span style=3D"color:#008">typename</span><span style=3D"co=
lor:#660">...</span><span style=3D"color:#000"> </span><span style=3D"color=
:#606">Ts</span><span style=3D"color:#660">></span><span style=3D"color:=
#000"><br></span><span style=3D"color:#008">void</span><span style=3D"color=
:#000"> f</span><span style=3D"color:#660">(</span><span style=3D"color:#60=
6">Ts</span><span style=3D"color:#660">&&...</span><span style=3D"c=
olor:#000"> ts</span><span style=3D"color:#660">)</span><span style=3D"colo=
r:#000"><br></span><span style=3D"color:#660">{</span><span style=3D"color:=
#000"><br>=C2=A0 =C2=A0 </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"=
color:#066">1</span><span style=3D"color:#660">:</span><span style=3D"color=
:#066">3</span><span style=3D"color:#660">]</span><span style=3D"color:#000=
">ts </span><span style=3D"color:#660">=3D</span><span style=3D"color:#000"=
> </span><span style=3D"color:#066">42</span><span style=3D"color:#660">));=
</span><span style=3D"color:#000"> =C2=A0</span><span style=3D"color:#800">=
// pack on LHS of assignment, plus a C++17 fold-expression with operator-co=
mma</span><span style=3D"color:#000"><br></span><span style=3D"color:#660">=
}</span><span style=3D"color:#000"><br><br></span><span style=3D"color:#008=
">int</span><span style=3D"color:#000"> main</span><span style=3D"color:#66=
0">()</span><span style=3D"color:#000"><br></span><span style=3D"color:#660=
">{</span><span style=3D"color:#000"><br>=C2=A0 =C2=A0 </span><span style=
=3D"color:#008">static</span><span style=3D"color:#000"> </span><span style=
=3D"color:#008">int</span><span style=3D"color:#000"> v0</span><span style=
=3D"color:#660">,</span><span style=3D"color:#000">v1</span><span style=3D"=
color:#660">,</span><span style=3D"color:#000">v2</span><span style=3D"colo=
r:#660">,</span><span style=3D"color:#000">v3</span><span style=3D"color:#6=
60">,</span><span style=3D"color:#000">v4</span><span style=3D"color:#660">=
;</span><span style=3D"color:#000"><br>=C2=A0 =C2=A0 f</span><span style=3D=
"color:#660">(</span><span style=3D"color:#000">v0</span><span style=3D"col=
or:#660">,</span><span style=3D"color:#000">v1</span><span style=3D"color:#=
660">,</span><span style=3D"color:#000">v2</span><span style=3D"color:#660"=
>,</span><span style=3D"color:#000">v3</span><span style=3D"color:#660">,</=
span><span style=3D"color:#000">v4</span><span style=3D"color:#660">);</spa=
n><span style=3D"color:#000"><br>=C2=A0 =C2=A0 </span><span style=3D"color:=
#008">assert</span><span style=3D"color:#660">(</span><span style=3D"color:=
#000">v0</span><span style=3D"color:#660">=3D=3D</span><span style=3D"color=
:#066">0</span><span style=3D"color:#000"> </span><span style=3D"color:#660=
">&&</span><span style=3D"color:#000"> v1</span><span style=3D"colo=
r:#660">=3D=3D</span><span style=3D"color:#066">42</span><span style=3D"col=
or:#000"> </span><span style=3D"color:#660">&&</span><span style=3D=
"color:#000"> v2</span><span style=3D"color:#660">=3D=3D</span><span style=
=3D"color:#066">42</span><span style=3D"color:#000"> </span><span style=3D"=
color:#660">&&</span><span style=3D"color:#000"> v3</span><span sty=
le=3D"color:#660">=3D=3D</span><span style=3D"color:#066">0</span><span sty=
le=3D"color:#000"> </span><span style=3D"color:#660">&&</span><span=
style=3D"color:#000"> v4</span><span style=3D"color:#660">=3D=3D</span><sp=
an style=3D"color:#066">0</span><span style=3D"color:#660">);</span><span s=
tyle=3D"color:#000"><br></span><span style=3D"color:#660">}</span></div></c=
ode></div><div><br></div><div><br></div><div>would indeed fall out naturall=
y. But I believe that what Vicente was referring to is Python's syntax =
for assigning into a slice of a list:</div><div><br></div></div></blockquot=
e><div><br></div><div>Given what slicing means in Python and what how unpac=
king typically works in C++, I think the more natural falling out is:</div>=
<div><br></div><div><div class=3D"prettyprint" style=3D"background-color: r=
gb(250, 250, 250); border-color: rgb(187, 187, 187); border-style: solid; b=
order-width: 1px; word-wrap: break-word;"><code class=3D"prettyprint"><div =
class=3D"subprettyprint"><span style=3D"color: #660;" class=3D"styled-by-pr=
ettify">[</span><font color=3D"#000000"><span style=3D"color: #066;" class=
=3D"styled-by-prettify">1</span><span style=3D"color: #660;" class=3D"style=
d-by-prettify">:</span><span style=3D"color: #066;" class=3D"styled-by-pret=
tify">3</span><span style=3D"color: #660;" class=3D"styled-by-prettify">]</=
span><span style=3D"color: #000;" class=3D"styled-by-prettify">ts</span><sp=
an style=3D"color: #800;" class=3D"styled-by-prettify">#0 =3D 42;</span><sp=
an style=3D"color: #000;" class=3D"styled-by-prettify"><br></span><span sty=
le=3D"color: #660;" class=3D"styled-by-prettify">[</span><span style=3D"col=
or: #066;" class=3D"styled-by-prettify">1</span><span style=3D"color: #660;=
" class=3D"styled-by-prettify">:</span><span style=3D"color: #066;" class=
=3D"styled-by-prettify">3</span><span style=3D"color: #660;" class=3D"style=
d-by-prettify">]</span><span style=3D"color: #000;" class=3D"styled-by-pret=
tify">ts</span><span style=3D"color: #800;" class=3D"styled-by-prettify">#1=
=3D 42;</span><span style=3D"color: #000;" class=3D"styled-by-prettify"><b=
r></span><span style=3D"color: #660;" class=3D"styled-by-prettify">...</spa=
n><span style=3D"color: #000;" class=3D"styled-by-prettify"><br></span><spa=
n style=3D"color: #660;" class=3D"styled-by-prettify">[</span><span style=
=3D"color: #066;" class=3D"styled-by-prettify">1</span><span style=3D"color=
: #660;" class=3D"styled-by-prettify">:</span><span style=3D"color: #066;" =
class=3D"styled-by-prettify">3</span><span style=3D"color: #660;" class=3D"=
styled-by-prettify">]</span><span style=3D"color: #000;" class=3D"styled-by=
-prettify">ts</span><span style=3D"color: #800;" class=3D"styled-by-prettif=
y">#N-1 =3D 42;</span></font></div></code></div><div><br></div>not</div><di=
v><br></div><div><div class=3D"prettyprint" style=3D"background-color: rgb(=
250, 250, 250); border-color: rgb(187, 187, 187); border-style: solid; bord=
er-width: 1px; word-wrap: break-word;"><code class=3D"prettyprint"><div cla=
ss=3D"subprettyprint"><font color=3D"#660066"><span style=3D"color: #000;" =
class=3D"styled-by-prettify">ts</span><span style=3D"color: #800;" class=3D=
"styled-by-prettify">#1 =3D 42;</span><span style=3D"color: #000;" class=3D=
"styled-by-prettify"><br>ts</span><span style=3D"color: #800;" class=3D"sty=
led-by-prettify">#2 =3D 42;</span></font></div></code></div><br>Also, the p=
aper has these two examples:</div><div><br></div><div><br></div><div><pre c=
lass=3D"code c++ literal-block" style=3D"margin-left: 2em; margin-right: 2e=
m; background-color: rgb(238, 238, 238); color: rgb(0, 0, 0);"><span class=
=3D"keyword" style=3D"color: rgb(59, 13, 6); font-weight: bold;">auto</span=
> <span class=3D"name">manhattan_distance</span> <span class=3D"name">d</sp=
an> <span class=3D"operator">=3D</span> <span class=3D"name">std</span><spa=
n class=3D"operator">::</span><span class=3D"name">abs</span><span class=3D=
"punctuation">([</span><span class=3D"operator">:</span><span class=3D"punc=
tuation">]</span><span class=3D"name">v</span><span class=3D"punctuation">)=
</span> <span class=3D"operator">+</span> <span class=3D"punctuation">...;<=
/span>
<span class=3D"keyword" style=3D"color: rgb(59, 13, 6); font-weight: bold;"=
>auto</span> <span class=3D"name">dot</span> <span class=3D"operator">=3D</=
span> <span class=3D"punctuation">[</span><span class=3D"operator">:</span>=
<span class=3D"punctuation">]</span><span class=3D"name">v</span> <span cla=
ss=3D"operator">*</span> <span class=3D"punctuation">...;</span></pre></div=
><div><br></div><div>Aside from the extra "d", what are these sup=
posed to do? Both Manhattan distance and dot product are functions of two v=
ectors, so I don't entirely understand this example.=C2=A0</div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" 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/f451bb5f-3575-47e3-b507-677c530f6d01%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/f451bb5f-3575-47e3-b507-677c530f6d01=
%40isocpp.org</a>.<br />
------=_Part_5734_1991194823.1482245256477--
------=_Part_5733_1354524053.1482245256476--
.
Author: Nicol Bolas <jmckesson@gmail.com>
Date: Tue, 20 Dec 2016 07:41:26 -0800 (PST)
Raw View
------=_Part_1545_1784455.1482248486509
Content-Type: multipart/alternative;
boundary="----=_Part_1546_899850883.1482248486509"
------=_Part_1546_899850883.1482248486509
Content-Type: text/plain; charset=UTF-8
On Tuesday, December 20, 2016 at 9:47:36 AM UTC-5, Barry Revzin wrote:
>
> Also, the paper has these two examples:
>
>
> auto manhattan_distance d = std::abs([:]v) + ...;auto dot = [:]v * ...;
>
>
> Aside from the extra "d", what are these supposed to do? Both Manhattan
> distance and dot product are functions of two vectors, so I don't entirely
> understand this example.
>
Well, here's what these would actually look like:
auto manhattan_distance = std::abs([:]v1 - [:]v2) + ...
auto dot = ([:]v1 * [:]v2) + ...;
--
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/993123ca-1701-4206-8cb6-44c5c36b689c%40isocpp.org.
------=_Part_1546_899850883.1482248486509
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">On Tuesday, December 20, 2016 at 9:47:36 AM UTC-5, Barry R=
evzin wrote:<blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-lef=
t: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div>Also, the pap=
er has these two examples:</div><div><br></div><div><br></div><div><pre sty=
le=3D"margin-left:2em;margin-right:2em;background-color:rgb(238,238,238);co=
lor:rgb(0,0,0)"><span style=3D"color:rgb(59,13,6);font-weight:bold">auto</s=
pan> <span>manhattan_distance</span> <span>d</span> <span>=3D</span> <span>=
std</span><span>::</span><span>abs</span><span>([</span><span>:</span><span=
>]</span><span>v</span><span>)</span> <span>+</span> <span>...;</span>
<span style=3D"color:rgb(59,13,6);font-weight:bold">auto</span> <span>dot</=
span> <span>=3D</span> <span>[</span><span>:</span><span>]</span><span>v</s=
pan> <span>*</span> <span>...;</span></pre></div><div><br></div><div>Aside =
from the extra "d", what are these supposed to do? Both Manhattan=
distance and dot product are functions of two vectors, so I don't enti=
rely understand this example.</div></blockquote><div><br>Well, here's w=
hat these would actually look like:<br><br><div style=3D"background-color: =
rgb(250, 250, 250); border-color: rgb(187, 187, 187); border-style: solid; =
border-width: 1px; overflow-wrap: break-word;" class=3D"prettyprint"><code =
class=3D"prettyprint"><div class=3D"subprettyprint"><span style=3D"color: #=
008;" class=3D"styled-by-prettify">auto</span><span style=3D"color: #000;" =
class=3D"styled-by-prettify"> manhattan_distance </span><span style=3D"colo=
r: #660;" class=3D"styled-by-prettify">=3D</span><span style=3D"color: #000=
;" class=3D"styled-by-prettify"> std</span><span style=3D"color: #660;" cla=
ss=3D"styled-by-prettify">::</span><span style=3D"color: #000;" class=3D"st=
yled-by-prettify">abs</span><span style=3D"color: #660;" class=3D"styled-by=
-prettify">([:]</span><span style=3D"color: #000;" class=3D"styled-by-prett=
ify">v1 </span><span style=3D"color: #660;" class=3D"styled-by-prettify">-<=
/span><span style=3D"color: #000;" class=3D"styled-by-prettify"> </span><sp=
an style=3D"color: #660;" class=3D"styled-by-prettify">[:]</span><span styl=
e=3D"color: #000;" class=3D"styled-by-prettify">v2</span><span style=3D"col=
or: #660;" class=3D"styled-by-prettify">)</span><span style=3D"color: #000;=
" class=3D"styled-by-prettify"> </span><span style=3D"color: #660;" class=
=3D"styled-by-prettify">+</span><span style=3D"color: #000;" class=3D"style=
d-by-prettify"> </span><span style=3D"color: #660;" class=3D"styled-by-pret=
tify">...</span><span style=3D"color: #000;" class=3D"styled-by-prettify"><=
br></span><span style=3D"color: #008;" class=3D"styled-by-prettify">auto</s=
pan><span style=3D"color: #000;" class=3D"styled-by-prettify"> dot </span><=
span style=3D"color: #660;" class=3D"styled-by-prettify">=3D</span><span st=
yle=3D"color: #000;" class=3D"styled-by-prettify"> </span><span style=3D"co=
lor: #660;" class=3D"styled-by-prettify">([:]</span><span style=3D"color: #=
000;" class=3D"styled-by-prettify">v1 </span><span style=3D"color: #660;" c=
lass=3D"styled-by-prettify">*</span><span style=3D"color: #000;" class=3D"s=
tyled-by-prettify"> </span><span style=3D"color: #660;" class=3D"styled-by-=
prettify">[:]</span><span style=3D"color: #000;" class=3D"styled-by-prettif=
y">v2</span><span style=3D"color: #660;" class=3D"styled-by-prettify">)</sp=
an><span style=3D"color: #000;" class=3D"styled-by-prettify"> </span><span =
style=3D"color: #660;" class=3D"styled-by-prettify">+</span><span style=3D"=
color: #000;" class=3D"styled-by-prettify"> </span><span style=3D"color: #6=
60;" class=3D"styled-by-prettify">...;</span><span style=3D"color: #000;" c=
lass=3D"styled-by-prettify"><br></span></div></code></div><br></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" 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/993123ca-1701-4206-8cb6-44c5c36b689c%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/993123ca-1701-4206-8cb6-44c5c36b689c=
%40isocpp.org</a>.<br />
------=_Part_1546_899850883.1482248486509--
------=_Part_1545_1784455.1482248486509--
.
Author: Matthew Woehlke <mwoehlke.floss@gmail.com>
Date: Tue, 20 Dec 2016 10:58:53 -0500
Raw View
On 2016-12-19 19:16, Vicente J. Botet Escriba wrote:
> I'm not against redefining sizeof for product types, but it will be
> worth mentioning the syntax is possible sizeof([:]t...) without the
> redefinition.
Pretty sure you meant `sizeof...([:]t)`, but yeah, it's a fair point. My
main argument for having `sizeof...(t)` for product type `t` is for
symmetry with prefix `[]` working on either packs or product types. If
folks don't find the consistency argument compelling, I have no problem
dropping that part of the proposal.
> The <double, double> returned in
>
> <double, double> calculateTargetCoordinates();
>
> is not a parameter pack but a pack type as defined in P0341. This is of
> course something new.
....but the expression `calculateTargetCoordinates()` results in a
parameter pack, does it not? That, anyway, is how I read P0341...
(Admittedly, I find P0341... vague and sometimes confusing.)
> Pack types as defined in P0341 should accept this slice operator (we
> shoild consider Pack types as product types). I'm not sure we will need
> that Pack types provide directly the expansion operator....
I hope that this will obviate much of P0341 :-). As I've said in various
places, while the features of P0341 are useful, I don't feel that the
approach in P0341 is desirable; it invents way too much IMHO in the way
of new syntax, new language constructs, etc..
> Have you considered strides [start:stop:step]? reverted slices
> [start:stop:-1]?
I hadn't specifically, but I'll refer you to "Future Direction". My
general impression has been that the more complicated the feature
becomes, the more people are inclined to dislike it. I think pack
generators or other such approaches would be a better solution for this
sort of thing.
> The main difference between the proposed slice operator and python
> slices is that the result is not a type, but a parameter pack, that can
> not be on the LHS of an assignment. Have you considered this possibility?
Doesn't std::tie solve that?
--
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.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/5859553D.2050106%40gmail.com.
.
Author: Matthew Woehlke <mwoehlke.floss@gmail.com>
Date: Tue, 20 Dec 2016 11:55:53 -0500
Raw View
On 2016-12-20 09:47, Barry Revzin wrote:
> On 2016-12-19 23:34, Arthur O'Dwyer wrote:
>> I believe that what Vicente was referring to is Python's syntax for
>> assigning into a slice of a list:
>>
>> >>> x = [0,1,2,3,4]
>> >>> x[1:3] = [42]
>> >>> print x
>> [0, 42, 3, 4]
Eek... yeah, I don't see that happening in C++. Not with parameter
packs, anyway.
> Given what slicing means in Python and what how unpacking typically works
> in C++, I think the more natural falling out is:
>
> [1:3]ts#0 = 42;
> [1:3]ts#1 = 42;
> ...
> [1:3]ts#N-1 = 42;
I'm... not quite sure what you're saying here?
At any rate, I would say that slices should work no different from other
parameter packs. I'm not sure if this is allowed or not (I think no?):
pack = 42;
....but such an operation on a slice, e.g. `[L:U]pt = 42`, should be
treated the same way.
> Also, the paper has these two examples:
> [snip]
Arf... thanks for catching those, and to Nicol for providing corrected
versions!
--
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.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/58596299.8040508%40gmail.com.
.
Author: "Vicente J. Botet Escriba" <vicente.botet@wanadoo.fr>
Date: Tue, 20 Dec 2016 23:11:14 +0100
Raw View
This is a multi-part message in MIME format.
--------------01CED941D81D86C77ACC249C
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: quoted-printable
Le 20/12/2016 =C3=A0 04:33, Nicol Bolas a =C3=A9crit :
>
>
> On Monday, December 19, 2016 at 7:16:08 PM UTC-5, Vicente J. Botet=20
> Escriba wrote:
>
> Le 19/12/2016 =C3=A0 20:19, Matthew Woehlke a =C3=A9crit :
>> I've talked about this on numerous occasions... here at last is a fo=
rmal
>> paper. Comments appreciated!
>>
>> I'd also appreciate if anyone has good, concrete examples for why
>> extracting single elements from a pack is useful.
>>
>> Short Summary:
>> --------------
>>
>> Add a syntax for slicing parameter packs. Extend this syntax to also
>> work on product types. Gain ability to convert a product type to a
>> parameter pack in the process.
>>
>> Longer summary:
>> ---------------
>>
>> This is a two-part proposal.
>>
>> The first part proposes to add parameter pack slicing, of the form
>> `[I]pack` or `[L:U]pack`. The first syntax says to take the `I`th
>> element of the pack, and produces a single value. The second syntax =
says
>> to take the elements of the pack with indices from `L` (inclusive) u=
ntil
>> `U` (exclusive), and produces a modified pack. Either bound may be
>> omitted, and negative indices may be used to indicate 'count from en=
d'
>> semantics. Accordingly, `[:]pack` is a no-op. (Slicing has higher
>> precedence than fold expansion. Refer to the paper for more specific=
s.)
>>
>> The second part proposes that parameter pack operations, particularl=
y
>> slicing (as in the first part), but also (optionally) `sizeof...`,
>> should also work on product types as well as packs. Critically, this
>> means that the following would now be semantically equivalent:
>>
>> std::apply(foo, pt);
>> foo([:]pt...);
>>
>> Please refer to the paper for motivating examples.
>>
>> Postscript:
>> -----------
>>
>> Some links in this are known to be broken, as they are intended to r=
efer
>> to my other draft proposal re: allowing types to be defined in retur=
n
>> type specifications. See also
>> https://groups.google.com/a/isocpp.org/forum/#!topic/std-proposals/y=
7dyHcD_BKA
>> <https://groups.google.com/a/isocpp.org/forum/#%21topic/std-proposal=
s/y7dyHcD_BKA>.
>>
> Hi,
>
> glad to see such a proposal.
>
> I'm not against redefining sizeof for product types, but it will
> be worth mentioning the syntax is possible sizeof([:]t...) without
> the redefinition.
>
> I think the syntax would be `sizeof...([:]t)`. After all, `[:]t` is a=20
> pack, and `sizeof...` returns the number of elements in the pack. No=20
> need to redefine anything.
Oh yes. This is what I have in mind.
>
> The main difference between the proposed slice operator and python
> slices is that the result is not a type, but a parameter pack,
> that can not be on the LHS of an assignment. Have you considered
> this possibility?
>
> That can easily be handled by unpacking it into a tuple of references,=20
> which can be assigned to.=20
I know this possibility. I'm asking because the compiler should surely=20
be able to do better. Vicente
--=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.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/fa54f7aa-a1e6-0a40-c38e-f66d62ac6ccb%40wanadoo.f=
r.
--------------01CED941D81D86C77ACC249C
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
<html>
<head>
<meta content=3D"text/html; charset=3Dutf-8" http-equiv=3D"Content-Type=
">
</head>
<body bgcolor=3D"#FFFFFF" text=3D"#000000">
<div class=3D"moz-cite-prefix">Le 20/12/2016 =C3=A0 04:33, Nicol Bolas =
a
=C3=A9crit=C2=A0:<br>
</div>
<blockquote
cite=3D"mid:1cf9797b-6671-465a-999d-a5c62c92c038@isocpp.org"
type=3D"cite">
<div dir=3D"ltr"><br>
<br>
On Monday, December 19, 2016 at 7:16:08 PM UTC-5, Vicente J.
Botet Escriba wrote:
<blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-left:
0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;">
<div bgcolor=3D"#FFFFFF" text=3D"#000000">
<div>Le 19/12/2016 =C3=A0 20:19, Matthew Woehlke a =C3=A9crit=
=C2=A0:<br>
</div>
<blockquote type=3D"cite">
<pre>I've talked about this on numerous occasions... here at =
last is a formal
paper. Comments appreciated!
I'd also appreciate if anyone has good, concrete examples for why
extracting single elements from a pack is useful.
Short Summary:
--------------
Add a syntax for slicing parameter packs. Extend this syntax to also
work on product types. Gain ability to convert a product type to a
parameter pack in the process.
Longer summary:
---------------
This is a two-part proposal.
The first part proposes to add parameter pack slicing, of the form
`[I]pack` or `[L:U]pack`. The first syntax says to take the `I`th
element of the pack, and produces a single value. The second syntax says
to take the elements of the pack with indices from `L` (inclusive) until
`U` (exclusive), and produces a modified pack. Either bound may be
omitted, and negative indices may be used to indicate 'count from end'
semantics. Accordingly, `[:]pack` is a no-op. (Slicing has higher
precedence than fold expansion. Refer to the paper for more specifics.)
The second part proposes that parameter pack operations, particularly
slicing (as in the first part), but also (optionally) `sizeof...`,
should also work on product types as well as packs. Critically, this
means that the following would now be semantically equivalent:
std::apply(foo, pt);
foo([:]pt...);
Please refer to the paper for motivating examples.
Postscript:
-----------
Some links in this are known to be broken, as they are intended to refer
to my other draft proposal re: allowing types to be defined in return
type specifications. See also
<a moz-do-not-send=3D"true" href=3D"https://groups.google.com/a/isocpp.org/=
forum/#%21topic/std-proposals/y7dyHcD_BKA" target=3D"_blank" rel=3D"nofollo=
w" onmousedown=3D"this.href=3D'https://groups.google.com/a/isocpp.org/forum=
/#!topic/std-proposals/y7dyHcD_BKA';return true;" onclick=3D"this.href=3D'h=
ttps://groups.google.com/a/isocpp.org/forum/#!topic/std-proposals/y7dyHcD_B=
KA';return true;">https://groups.google.com/a/<wbr>isocpp.org/forum/#!topic=
/std-<wbr>proposals/y7dyHcD_BKA</a>.
</pre>
</blockquote>
<p>Hi,</p>
<p>glad to see such a proposal.</p>
<p>I'm not against redefining sizeof for product types, but it will
be worth mentioning the syntax is possible sizeof([:]t...) without
the redefinition.
</p></div></blockquote><div>
I think the syntax would be `sizeof...([:]t)`. After all, `[:]t` is a pack,=
and `sizeof...` returns the number of elements in the pack. No need to red=
efine anything.</div></div></blockquote>Oh yes. This is what I have in mind=
..
<blockquote cite=3D"mid:1cf9797b-6671-465a-999d-a5c62c92c038@isocpp.org" ty=
pe=3D"cite"><div dir=3D"ltr"><div>=C2=A0</div><blockquote class=3D"gmail_qu=
ote" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;padd=
ing-left: 1ex;"><div bgcolor=3D"#FFFFFF" text=3D"#000000"><p><span>
</span></p>
<p><span>The main difference between the
proposed slice operator and python slices is that the result is
not a type, but a parameter pack, that can not be on the LHS of
an assignment. Have you considered this possibility?
</span></p></div></blockquote><div>
</div>That can easily be handled by unpacking it into a tuple of references=
, which can be assigned to.
</div></blockquote>I know this possibility. I'm asking because the compiler=
should surely be able to do better.
Vicente
</body></html>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" 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/fa54f7aa-a1e6-0a40-c38e-f66d62ac6ccb%=
40wanadoo.fr?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/fa54f7aa-a1e6-0a40-c38e-f66d62ac6ccb=
%40wanadoo.fr</a>.<br />
--------------01CED941D81D86C77ACC249C--
.
Author: Bengt Gustafsson <bengt.gustafsson@beamways.com>
Date: Tue, 20 Dec 2016 15:52:22 -0800 (PST)
Raw View
------=_Part_1763_1800860291.1482277942719
Content-Type: multipart/alternative;
boundary="----=_Part_1764_1583249160.1482277942719"
------=_Part_1764_1583249160.1482277942719
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
I really like this feature for packs. For "product types" such as tuples=20
I'm more reserved. It seems that converting the product type object to a=20
value pack is the principal operation, and that any slicing should take=20
place after the product type object has been converted to a pack. Using the=
=20
"nop slice" for this purpose feels contrived.
With this in mind I think a postfix [] would be easier to understand. We=20
already have both compile time (array bounds) and runtime (indexing and=20
array-new) uses of [].
If we get constexpr function parameters I would say that a=20
operator[](constexpr size_t) on tuple would be close at hand. With this=20
proposal and that [0]tup and tup[0] would do the same thing. That's why I=
=20
think the cleanest would be to limit this proposal to packs and use postfix=
=20
indexing.
With the advent of [:] for slicing a future direction could be to allow=20
this type of indexing to be overloaded for user defined types (with and=20
without constexpr parameters). This would enable slicing of a tuple to a=20
shorter tuple using tup[1:3] type of syntax.
Right now I don't have any idea on what operator to use for converting a=20
product type to a pack, but maybe that was what the operator...()=20
overloading was about?
Den m=C3=A5ndag 19 december 2016 kl. 20:20:00 UTC+1 skrev Matthew Woehlke:
>
> I've talked about this on numerous occasions... here at last is a formal=
=20
> paper. Comments appreciated!=20
>
> I'd also appreciate if anyone has good, concrete examples for why=20
> extracting single elements from a pack is useful.=20
>
> Short Summary:=20
> --------------=20
>
> Add a syntax for slicing parameter packs. Extend this syntax to also=20
> work on product types. Gain ability to convert a product type to a=20
> parameter pack in the process.=20
>
> Longer summary:=20
> ---------------=20
>
> This is a two-part proposal.=20
>
> The first part proposes to add parameter pack slicing, of the form=20
> `[I]pack` or `[L:U]pack`. The first syntax says to take the `I`th=20
> element of the pack, and produces a single value. The second syntax says=
=20
> to take the elements of the pack with indices from `L` (inclusive) until=
=20
> `U` (exclusive), and produces a modified pack. Either bound may be=20
> omitted, and negative indices may be used to indicate 'count from end'=20
> semantics. Accordingly, `[:]pack` is a no-op. (Slicing has higher=20
> precedence than fold expansion. Refer to the paper for more specifics.)=
=20
>
> The second part proposes that parameter pack operations, particularly=20
> slicing (as in the first part), but also (optionally) `sizeof...`,=20
> should also work on product types as well as packs. Critically, this=20
> means that the following would now be semantically equivalent:=20
>
> std::apply(foo, pt);=20
> foo([:]pt...);=20
>
> Please refer to the paper for motivating examples.=20
>
> Postscript:=20
> -----------=20
>
> Some links in this are known to be broken, as they are intended to refer=
=20
> to my other draft proposal re: allowing types to be defined in return=20
> type specifications. See also=20
>
> https://groups.google.com/a/isocpp.org/forum/#!topic/std-proposals/y7dyHc=
D_BKA.=20
>
>
> --=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.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/55b23560-f19b-404c-bc58-dbd71cadb26f%40isocpp.or=
g.
------=_Part_1764_1583249160.1482277942719
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">I really like this feature for packs. For "product ty=
pes" such as tuples I'm more reserved. It seems that converting th=
e product type object to a value pack is the principal operation, and that =
any slicing should take place after the product type object has been conver=
ted to a pack. Using the "nop slice" for this purpose feels contr=
ived.<div><br></div><div>With this in mind I think a postfix [] would be ea=
sier to understand. We already have both compile time (array bounds) and ru=
ntime (indexing and array-new) uses of [].</div><div><br></div><div>If we g=
et constexpr function parameters I would say that a operator[](constexpr si=
ze_t) on tuple would be close at hand. With this proposal and that [0]tup a=
nd tup[0] would do the same thing. That's why I think the cleanest woul=
d be to limit this proposal to packs and use postfix indexing.</div><div><b=
r></div><div>With the advent of [:] for slicing a future direction could be=
to allow this type of indexing to be overloaded for user defined types (wi=
th and without constexpr parameters). This would enable slicing of a tuple =
to a shorter tuple using tup[1:3] type of syntax.</div><div><br></div><div>=
Right now I don't have any idea on what operator to use for converting =
a product type to a pack, but maybe that was what the operator...() overloa=
ding was about?</div><div><br></div><div><br></div><div><br><br>Den m=C3=A5=
ndag 19 december 2016 kl. 20:20:00 UTC+1 skrev Matthew Woehlke:<blockquote =
class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1p=
x #ccc solid;padding-left: 1ex;">I've talked about this on numerous occ=
asions... here at last is a formal
<br>paper. Comments appreciated!
<br>
<br>I'd also appreciate if anyone has good, concrete examples for why
<br>extracting single elements from a pack is useful.
<br>
<br>Short Summary:
<br>--------------
<br>
<br>Add a syntax for slicing parameter packs. Extend this syntax to also
<br>work on product types. Gain ability to convert a product type to a
<br>parameter pack in the process.
<br>
<br>Longer summary:
<br>---------------
<br>
<br>This is a two-part proposal.
<br>
<br>The first part proposes to add parameter pack slicing, of the form
<br>`[I]pack` or `[L:U]pack`. The first syntax says to take the `I`th
<br>element of the pack, and produces a single value. The second syntax say=
s
<br>to take the elements of the pack with indices from `L` (inclusive) unti=
l
<br>`U` (exclusive), and produces a modified pack. Either bound may be
<br>omitted, and negative indices may be used to indicate 'count from e=
nd'
<br>semantics. Accordingly, `[:]pack` is a no-op. (Slicing has higher
<br>precedence than fold expansion. Refer to the paper for more specifics.)
<br>
<br>The second part proposes that parameter pack operations, particularly
<br>slicing (as in the first part), but also (optionally) `sizeof...`,
<br>should also work on product types as well as packs. Critically, this
<br>means that the following would now be semantically equivalent:
<br>
<br>=C2=A0 std::apply(foo, pt);
<br>=C2=A0 foo([:]pt...);
<br>
<br>Please refer to the paper for motivating examples.
<br>
<br>Postscript:
<br>-----------
<br>
<br>Some links in this are known to be broken, as they are intended to refe=
r
<br>to my other draft proposal re: allowing types to be defined in return
<br>type specifications. See also
<br><a href=3D"https://groups.google.com/a/isocpp.org/forum/#!topic/std-pro=
posals/y7dyHcD_BKA" target=3D"_blank" rel=3D"nofollow" onmousedown=3D"this.=
href=3D'https://groups.google.com/a/isocpp.org/forum/#!topic/std-propos=
als/y7dyHcD_BKA';return true;" onclick=3D"this.href=3D'https://grou=
ps.google.com/a/isocpp.org/forum/#!topic/std-proposals/y7dyHcD_BKA';ret=
urn true;">https://groups.google.com/a/<wbr>isocpp.org/forum/#!topic/std-<w=
br>proposals/y7dyHcD_BKA</a>.
<br>
<br>--=20
<br>Matthew
<br></blockquote></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" 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/55b23560-f19b-404c-bc58-dbd71cadb26f%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/55b23560-f19b-404c-bc58-dbd71cadb26f=
%40isocpp.org</a>.<br />
------=_Part_1764_1583249160.1482277942719--
------=_Part_1763_1800860291.1482277942719--
.
Author: Nicol Bolas <jmckesson@gmail.com>
Date: Tue, 20 Dec 2016 17:46:46 -0800 (PST)
Raw View
------=_Part_6544_356646026.1482284806610
Content-Type: multipart/alternative;
boundary="----=_Part_6545_607163381.1482284806610"
------=_Part_6545_607163381.1482284806610
Content-Type: text/plain; charset=UTF-8
On Tuesday, December 20, 2016 at 6:52:22 PM UTC-5, Bengt Gustafsson wrote:
>
> I really like this feature for packs. For "product types" such as tuples
> I'm more reserved.
>
But without the tuple part of it, it basically isn't a feature anymore. So
you can subselect from a parameter pack. That's not nearly a common enough
operation to be worth adding syntax for.
> It seems that converting the product type object to a value pack is the
> principal operation, and that any slicing should take place after the
> product type object has been converted to a pack. Using the "nop slice" for
> this purpose feels contrived.
>
OK, let's look at this logically. You want syntax A which means "convert
tuple to pack". And you want syntax B which means "sub-select pack from
pack".
Now, let's say I want to sub-select from a tuple. Well, that means I have
to apply syntax A then syntax B. But we know that you cannot sub-select a
pack from a tuple, so applying syntax B to a tuple would be a compile
error. So there would be no harm in making syntax B implicitly perform A
when applied to a tuple. After all, you're just doing what the user
obviously wants, right?
At which point, you can simply declare that syntax A is merely a degenerate
form of syntax B. And thus, you've re-derived this proposal.
If the use wants to subselect a tuple from a tuple, they can do that:
`tuple([1:3]tup...)`. This also allows them to choose *how* to build that
tuple. The above would perform a copy of the elements.
`forward_as_tuple([1:3]tup...)` would get references from them.
--
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/e0128bc8-7082-4740-a7ce-cb5a7b1d74c8%40isocpp.org.
------=_Part_6545_607163381.1482284806610
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">On Tuesday, December 20, 2016 at 6:52:22 PM UTC-5, Bengt G=
ustafsson 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"lt=
r">I really like this feature for packs. For "product types" such=
as tuples I'm more reserved.</div></blockquote><div><br>But without th=
e tuple part of it, it basically isn't a feature anymore. So you can su=
bselect from a parameter pack. That's not nearly a common enough operat=
ion to be worth adding syntax for.<br>=C2=A0</div><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">It seems that converting the product t=
ype object to a value pack is the principal operation, and that any slicing=
should take place after the product type object has been converted to a pa=
ck. Using the "nop slice" for this purpose feels contrived.</div>=
</blockquote><div><br>OK, let's look at this logically. You want syntax=
A which means "convert tuple to pack". And you want syntax B whi=
ch means "sub-select pack from pack".<br><br>Now, let's say I=
want to sub-select from a tuple. Well, that means I have to apply syntax A=
then syntax B. But we know that you cannot sub-select a pack from a tuple,=
so applying syntax B to a tuple would be a compile error. So there would b=
e no harm in making syntax B implicitly perform A when applied to a tuple. =
After all, you're just doing what the user obviously wants, right?<br><=
br>At which point, you can simply declare that syntax A is merely a degener=
ate form of syntax B. And thus, you've re-derived this proposal.<br><br=
>If the use wants to subselect a tuple from a tuple, they can do that: `tup=
le([1:3]tup...)`. This also allows them to choose <i>how</i> to build that =
tuple. The above would perform a copy of the elements. `forward_as_tuple([1=
:3]tup...)` would get references from them.<br></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" 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/e0128bc8-7082-4740-a7ce-cb5a7b1d74c8%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/e0128bc8-7082-4740-a7ce-cb5a7b1d74c8=
%40isocpp.org</a>.<br />
------=_Part_6545_607163381.1482284806610--
------=_Part_6544_356646026.1482284806610--
.
Author: Matthew Woehlke <mwoehlke.floss@gmail.com>
Date: Wed, 21 Dec 2016 10:16:08 -0500
Raw View
On 2016-12-21 02:49, Vicente J. Botet Escriba wrote:
> If you consider [:] as a way to convert a product type to a parameter
> pack, slicing could become an additional operation.
....but then, what does it mean when applied to a pack?
I've structured the proposal as it is to try to minimize the new syntax
introduced. Particularly, there are exactly two new prefix operators, of
the form `[I]` and `[L:U]`, where `L` and/or `U` are optional (`I` is
required). Both work on *either* parameter packs or product types, and
both *produce*, respectively, a single value and a parameter pack,
regardless of the input. That `[:]` happens to also convert a product
type to a parameter pack is a "happy" (albeit intentional) side-effect.
> Le 20/12/2016 =C3=A0 16:58, Matthew Woehlke a =C3=A9crit :=20
>> ...but the expression `calculateTargetCoordinates()` results in a
>> parameter pack, does it not? That, anyway, is how I read P0341...
>> (Admittedly, I find P0341... vague and sometimes confusing.)
>
> I agree that the paper could be vague, but I know the intention is to be
> a type not a pack.
If it's a type, how is it different (besides syntax sugar) from a
compound type as we already have them?
> One of the major things P0341 proposes IMO is a type for aggregate
> initializes. <T, U> is the type for the expression { t, u }. This is
> something we are missing now.
Again, though, how is that different from a tuple? Or maybe it should be
spelled std::initializer_list<T, U>? At least, it seems to me it would
make more sense to give it a type name, even if it has a little of
initializer_list's "magic". Giving it *no* name creates a new, very
distinctive syntax that doesn't seem justified to me.
> The other is the ability to use packs in other locations, to help define
> a simple_tuple type.
For the record, *those* parts I'm generally not opposed to, at least not
on principle. (I'm not too sure about the exact syntax being proposed,
especially as said syntax is not clear, but the features seem okay in
principle.)
>> I hadn't specifically, but I'll refer you to "Future Direction". My
>> general impression has been that the more complicated the feature
>> becomes, the more people are inclined to dislike it. I think pack
>> generators or other such approaches would be a better solution for this
>> sort of thing.
>
> Maybe you are right, but exploring the global problem is worth the effort=
..
> It is not clear to me yet what pack generators are. I'll re-read the
> paper but a clarification here is welcome.
Talk to Daveed; it's his paper. I really like it, but for some reason he
has never published it (I wish he would!).
The basic idea, though, is that it implements compile-time functions a
la Python's generators (https://wiki.python.org/moin/Generators), which
produce parameter packs. Basically, these let you do all sorts of
complicated things like zipping, stepping, reversing, producing
sequences, and so forth.
> With [:] and std::slice<I,J,K>(ts..) we can replace
>=20
> [I, J]pp // your proposed slice
>=20
> with
>=20
> [:]slice<I,,J>(pp...) // your proposed product type to parameter
> pack + a library function returning a product type view
....but this won't work on parameter packs without first converting them
to product types. At *best* it's a lot more verbose. And it doesn't
solve the problem of extracting single elements from parameter packs.
These are all things that the compiler can do *very easily*, but are
much harder if they have to be expressed as library functions. This is
why the proposal is presented as "let's solve parameter pack problems
(that are very hard to solve with library only approaches)" and "hey,
look how much more useful this is if we allow it to work on product
types as well".
> What I'm saying is that we need to see what are the minimal operations
> we need and what are the syntactic sugar ones.
The *bare minimum* is a) element extraction from a parameter pack, and
b) product type to tuple conversion. One might argue whether *parameter
pack* slicing is strictly needed, although it's a whole heck of a lot
messier and more verbose to try to do without it.
The thing is, with the presented syntax, once you have those, you *also*
get all the rest "for free" (without adding additional new syntax).
> While I would like to have a direct product type expansion, I don't see
> how P0341 UDT expansion works together with parameter pack expansions
>=20
> pt... // UDT product type expansion P0341
So... this just scares me; you're overloading the fold expression
operator to produce something that could be used in a fold expression. I
don't even want to *think* about the parsing headaches this is going to
create, not just for compilers, but for anyone trying to read the code.
> If we introduce a slice construct in the language for parameter packs,
> why it cannot be on the lhs of a expression?
What does it even *mean* to assign to a parameter pack? Parameter packs,
today, are not mutable. The proposed feature would introduce a limited
form of "mutating", although really it is creating a new pack from a
"view" of an existing pack. Think about Python tuples; a parameter pack
is a lot like a tuple. You can slice it, but you can't assign to it.
--=20
Matthew
--=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.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/585A9CB8.6000004%40gmail.com.
.
Author: Matthew Woehlke <mwoehlke.floss@gmail.com>
Date: Wed, 21 Dec 2016 10:58:30 -0500
Raw View
On 2016-12-20 18:52, Bengt Gustafsson wrote:
> I really like this feature for packs. For "product types" such as tuples
> I'm more reserved. It seems that converting the product type object to a
> value pack is the principal operation, and that any slicing should take
> place after the product type object has been converted to a pack. Using the
> "nop slice" for this purpose feels contrived.
It's a fair cop, but I've gone that route because it results in maximum
usefulness out of minimum syntax. Having a totally separate operation
for pt->pp conversion requires an additional syntax, vs. overloading the
pack slicing syntax, and then if you *do* want to slice a product type,
you'd have to use both, rather than just the one syntax. (See also
Nicol's reply.)
FWIW, it's not useless:
template <typename T, size_t N>
std::array<T, N-1> normalize(std::array<T, N> a)
{
return {[:-1]a / [-1]a...};
}
> If we get constexpr function parameters I would say that a
> operator[](constexpr size_t) on tuple would be close at hand.
Will it be provided by default (opt-out) for simple aggregates? Would we
*want* it for simple aggregates? It might be confusing to use "array
indexing" on something that isn't an array. Using a different (prefix)
but familiar (operator[]) addresses this.
--
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.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/585AA6A6.9090604%40gmail.com.
.
Author: Barry Revzin <barry.revzin@gmail.com>
Date: Wed, 21 Dec 2016 08:54:31 -0800 (PST)
Raw View
------=_Part_2052_2015113332.1482339271935
Content-Type: multipart/alternative;
boundary="----=_Part_2053_694413383.1482339271936"
------=_Part_2053_694413383.1482339271936
Content-Type: text/plain; charset=UTF-8
>
>
> > Given what slicing means in Python and what how unpacking typically
> works
> > in C++, I think the more natural falling out is:
> >
> > [1:3]ts#0 = 42;
> > [1:3]ts#1 = 42;
> > ...
> > [1:3]ts#N-1 = 42;
>
> I'm... not quite sure what you're saying here?
>
>
>
You're proposing that the [x:y] syntax can apply to both packs and product
types. The question is, in Arthur's example of:
(... , ([1:3]ts = 42));
How do you know whether this is
(a) Pick out two elements of the parameter pack ts... first, THEN assign 42
to both of those. That is, ts#1 = 42; ts#2 = 42;
(b) For each element in the parameter pack, that is a product type, do [1:3]elem
= 42; That is, [1:3]ts#0 = 42; [1:3]ts#1 = 42; ...; [1:3]ts#N-1 = 42;
Or more generally, I have a function:
template <class F, class... Ts>
void invoke(F f, Ts... ts) { ... }
And I want to implement invoke() such that it:
(a) calls f on each item in the slice [1:3] of the parameter pack ts. That
is, given invoke(f, a, b, c, d), I want it to do f(b); f(c);
(b) calls f on the sub-elements [1:3] of each element of the parameter pack
ts. That is, given invoke(f, a, b, c, d), I want it do f([1:3]a...);
f([1:3]b...); f([1:3]c...); f([1:3]d...);
How do I implement those two function calls?
--
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/980a124b-7c42-463e-93e4-2a44a51d8e1e%40isocpp.org.
------=_Part_2053_694413383.1482339271936
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;"><br>> Give=
n what slicing means in Python and what how unpacking typically works=20
<br>> in C++, I think the more natural falling out is:
<br>>=20
<br>> [1:3]ts#0 =3D 42;
<br>> [1:3]ts#1 =3D 42;
<br>> ...
<br>> [1:3]ts#N-1 =3D 42;
<br>
<br>I'm... not quite sure what you're saying here?
<br>
<br><br></blockquote><div><br></div><div>You're proposing that the [x:y=
] syntax can apply to both packs and product types. The question is, in Art=
hur's example of:</div><div><br></div><div><div class=3D"prettyprint" s=
tyle=3D"background-color: rgb(250, 250, 250); border-color: rgb(187, 187, 1=
87); border-style: solid; border-width: 1px; word-wrap: break-word;"><code =
class=3D"prettyprint"><div class=3D"subprettyprint"><span style=3D"color: r=
gb(102, 102, 0);"><span style=3D"color: #660;" class=3D"styled-by-prettify"=
>(...</span></span><span style=3D"color: rgb(0, 0, 0);"><span style=3D"colo=
r: #000;" class=3D"styled-by-prettify"> </span></span><span style=3D"color:=
rgb(102, 102, 0);"><span style=3D"color: #660;" class=3D"styled-by-prettif=
y">,</span></span><span style=3D"color: rgb(0, 0, 0);"><span style=3D"color=
: #000;" class=3D"styled-by-prettify"> </span></span><span style=3D"color: =
rgb(102, 102, 0);"><span style=3D"color: #660;" class=3D"styled-by-prettify=
">([</span></span><span style=3D"color: rgb(0, 102, 102);"><span style=3D"c=
olor: #066;" class=3D"styled-by-prettify">1</span></span><span style=3D"col=
or: rgb(102, 102, 0);"><span style=3D"color: #660;" class=3D"styled-by-pret=
tify">:</span></span><span style=3D"color: rgb(0, 102, 102);"><span style=
=3D"color: #066;" class=3D"styled-by-prettify">3</span></span><span style=
=3D"color: rgb(102, 102, 0);"><span style=3D"color: #660;" class=3D"styled-=
by-prettify">]</span></span><span style=3D"color: rgb(0, 0, 0);"><span styl=
e=3D"color: #000;" class=3D"styled-by-prettify">ts </span></span><span styl=
e=3D"color: rgb(102, 102, 0);"><span style=3D"color: #660;" class=3D"styled=
-by-prettify">=3D</span></span><span style=3D"color: rgb(0, 0, 0);"><span s=
tyle=3D"color: #000;" class=3D"styled-by-prettify"> </span></span><span sty=
le=3D"color: rgb(0, 102, 102);"><span style=3D"color: #066;" class=3D"style=
d-by-prettify">42</span></span><span style=3D"color: rgb(102, 102, 0);"><sp=
an style=3D"color: #660;" class=3D"styled-by-prettify">));</span></span><sp=
an style=3D"color: #000;" class=3D"styled-by-prettify"><br></span></div></c=
ode></div><br>How do you know whether this is</div><div>(a) Pick out two el=
ements of the parameter pack <font face=3D"courier new, monospace">ts...</f=
ont> first, THEN assign 42 to both of those. That is, <font face=3D"courier=
new, monospace">ts#1 =3D 42; ts#2 =3D 42;</font></div><div>(b) For each el=
ement in the parameter pack, that is a product type, do <font face=3D"couri=
er new, monospace">[1:3]elem =3D 42;</font> That is, <font face=3D"courier =
new, monospace">[1:3]ts#0 =3D 42; [1:3]ts#1 =3D 42; ...; [1:3]ts#N-1 =3D 42=
;</font></div><div><font face=3D"courier new, monospace"><br></font></div><=
div>Or more generally, I have a function:</div><div><br></div><div><div cla=
ss=3D"prettyprint" style=3D"background-color: rgb(250, 250, 250); border-co=
lor: rgb(187, 187, 187); border-style: solid; border-width: 1px; word-wrap:=
break-word;"><code class=3D"prettyprint"><div class=3D"subprettyprint"><fo=
nt color=3D"#660066"><span style=3D"color: #008;" class=3D"styled-by-pretti=
fy">template</span><span style=3D"color: #000;" class=3D"styled-by-prettify=
"> </span><span style=3D"color: #660;" class=3D"styled-by-prettify"><</s=
pan><span style=3D"color: #008;" class=3D"styled-by-prettify">class</span><=
span style=3D"color: #000;" class=3D"styled-by-prettify"> F</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: #008;=
" class=3D"styled-by-prettify">class</span><span style=3D"color: #660;" cla=
ss=3D"styled-by-prettify">...</span><span style=3D"color: #000;" class=3D"s=
tyled-by-prettify"> </span><span style=3D"color: #606;" class=3D"styled-by-=
prettify">Ts</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: #008;" class=3D"styled-by-prettify">void</span=
><span style=3D"color: #000;" class=3D"styled-by-prettify"> invoke</span><s=
pan style=3D"color: #660;" class=3D"styled-by-prettify">(</span><span style=
=3D"color: #000;" class=3D"styled-by-prettify">F f</span><span style=3D"col=
or: #660;" class=3D"styled-by-prettify">,</span><span style=3D"color: #000;=
" class=3D"styled-by-prettify"> </span><span style=3D"color: #606;" class=
=3D"styled-by-prettify">Ts</span><span style=3D"color: #660;" class=3D"styl=
ed-by-prettify">...</span><span style=3D"color: #000;" class=3D"styled-by-p=
rettify"> ts</span><span style=3D"color: #660;" class=3D"styled-by-prettify=
">)</span><span style=3D"color: #000;" class=3D"styled-by-prettify"> </span=
><span style=3D"color: #660;" class=3D"styled-by-prettify">{</span><span st=
yle=3D"color: #000;" class=3D"styled-by-prettify"> </span><span style=3D"co=
lor: #660;" class=3D"styled-by-prettify">...</span><span style=3D"color: #0=
00;" class=3D"styled-by-prettify"> </span><span style=3D"color: #660;" clas=
s=3D"styled-by-prettify">}</span></font></div></code></div><br><span style=
=3D"font-family: arial, sans-serif;">And I want to implement invoke() such =
that it:</span><br></div><div><span style=3D"font-family: arial, sans-serif=
;">(a) calls f on each item in the slice [1:3] of the parameter pack ts. Th=
at is, given </span><font face=3D"courier new, monospace">invoke(f, a, b, c=
, d)</font><span style=3D"font-family: arial, sans-serif;">, I want it to d=
o </span><font face=3D"courier new, monospace">f(b); f(c);</font></div><div=
><span style=3D"font-family: arial, sans-serif;">(b) calls f on the sub-ele=
ments [1:3] of each element of the parameter pack ts. That is, given </span=
><font face=3D"courier new, monospace">invoke(f, a, b, c, d)</font><span st=
yle=3D"font-family: arial, sans-serif;">, I want it do </span><font face=3D=
"courier new, monospace">f([1:3]a...); f([1:3]b...); f([1:3]c...); f([1:3]d=
....);</font></div><div><span style=3D"font-family: arial, sans-serif;"><br>=
</span></div><div><span style=3D"font-family: arial, sans-serif;">How do I =
implement those two function calls?</span></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" 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/980a124b-7c42-463e-93e4-2a44a51d8e1e%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/980a124b-7c42-463e-93e4-2a44a51d8e1e=
%40isocpp.org</a>.<br />
------=_Part_2053_694413383.1482339271936--
------=_Part_2052_2015113332.1482339271935--
.
Author: Matthew Woehlke <mwoehlke.floss@gmail.com>
Date: Wed, 21 Dec 2016 12:18:32 -0500
Raw View
On 2016-12-21 11:54, Barry Revzin wrote:
> You're proposing that the [x:y] syntax can apply to both packs and product
> types. The question is, in Arthur's example of:
>
> (... , ([1:3]ts = 42));
>
> How do you know whether this is
> (a) Pick out two elements of the parameter pack ts... first, THEN assign 42
> to both of those. That is, ts#1 = 42; ts#2 = 42;
> (b) For each element in the parameter pack, that is a product type, do [1:3]elem
> = 42; That is, [1:3]ts#0 = 42; [1:3]ts#1 = 42; ...; [1:3]ts#N-1 = 42;
The first; `[:]` has precedence over `...` (the proposal clearly states
this), therefore its operand is `ts`.
This delves partly into the problem of choosing how to apply fold
expressions in the context of multiple levels of packs. That's been
discussed before, and it's... hard. Hard enough that I'm not attempting
to solve that problem. Probably you need to use a lambda or other helper
function for such cases.
> Or more generally, I have a function:
>
> template <class F, class... Ts>
> void invoke(F f, Ts... ts) { ... }
>
> And I want to implement invoke() such that it:
> (a) calls f on each item in the slice [1:3] of the parameter pack ts. That
> is, given invoke(f, a, b, c, d), I want it to do f(b); f(c);
(void)(f([1:3]ts), ...);
> (b) calls f on the sub-elements [1:3] of each element of the parameter pack
> ts. That is, given invoke(f, a, b, c, d), I want it do f([1:3]a...);
> f([1:3]b...); f([1:3]c...); f([1:3]d...);
auto l = [](auto f, auto t) { f([1:3]t...); }
(void)(l(ts), ...);
For similar reasons, the proposed feature does not entirely obviate
std::apply.
--
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.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/585AB968.10206%40gmail.com.
.
Author: Matthew Woehlke <mwoehlke.floss@gmail.com>
Date: Thu, 12 Jan 2017 15:40:35 -0500
Raw View
On 2016-12-21 02:49, Vicente J. Botet Escriba wrote:
>>> The main difference between the proposed slice operator and python
>>> slices is that the result is not a type, but a parameter pack, that can
>>> not be on the LHS of an assignment. Have you considered this
>>> possibility?
>>
>> Doesn't std::tie solve that?
>
> Yes, std::tie will work. If what we want is
>
> [1,3]pp = {a,b},
>
> with tie, we need
>
> tie(([1,3]pp)...) = {a,b};
>
> Do we need to improve the syntactic sugar of each construction?
Oddly enough, a coworker was asking a similar question recently,
although for the example he gave, what he really wants is `auto const
[foo, bar] = ...`.
I was looking at this again, and I wonder how often you really want to
write something like the above, and why you wouldn't instead write it:
[1]pp = a;
[3]pp = b;
If this is really a useful feature, probably it should work on any
parameter pack, sliced or otherwise. That would make it orthogonal to
this proposal.
--
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.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/5877E9C3.9080303%40gmail.com.
.
Author: Matthew Woehlke <mwoehlke.floss@gmail.com>
Date: Thu, 12 Jan 2017 15:57:21 -0500
Raw View
On 2016-12-19 17:26, T. C. wrote:
> On Monday, December 19, 2016 at 4:11:33 PM UTC-5, Matthew Woehlke wrote:
>> The intent is that ``-marked text denotes a literal token. (This is
>> somewhat important when []s are being thrown around both as literal
>> tokens and this-is-optional indicators... Unfortunately, it is not easy
>> in reST to have text that is both bold and literal.)
>
> I see (I thought that the backticks were remnants from the source). You
> might want to consider the way the standard's grammar indicates optional
> elements instead (subscript "opt")
Thanks. I've tweaked this a bunch. The current version does not have
backticks, uses bold for stuff that appears literally, italic for
placeholders, and subscript "opt" for optional stuff. (Yay for custom
roles and custom CSS!)
>> Which syntax is broken?
>
> Lack of return type on apply and apply_helper. Template parameter list
> after the declarator-id for the latter.
Should be fixed in the latest version.
--
Matthew
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/5877EDB1.4050308%40gmail.com.
.
Author: Matthew Woehlke <mwoehlke.floss@gmail.com>
Date: Wed, 1 Feb 2017 19:00:50 -0500
Raw View
This is a multi-part message in MIME format.
--------------080309090707090004030800
Content-Type: text/plain; charset=UTF-8
I'm posting an update, since there have been non-trivial changes to the
examples and some discussion questions, partly thanks to some in depth
discussions with Bengt Gustafsson.
Again, feedback appreciated, especially on the examples and discussion
points. (The original summary, for context, is quoted below.)
Matthew
On 2016-12-19 14:19, Matthew Woehlke wrote:
> Short Summary:
> --------------
>
> Add a syntax for slicing parameter packs. Extend this syntax to also
> work on product types. Gain ability to convert a product type to a
> parameter pack in the process.
>
> Longer summary:
> ---------------
>
> This is a two-part proposal.
>
> The first part proposes to add parameter pack slicing, of the form
> `[I]pack` or `[L:U]pack`. The first syntax says to take the `I`th
> element of the pack, and produces a single value. The second syntax says
> to take the elements of the pack with indices from `L` (inclusive) until
> `U` (exclusive), and produces a modified pack. Either bound may be
> omitted, and negative indices may be used to indicate 'count from end'
> semantics. Accordingly, `[:]pack` is a no-op. (Slicing has higher
> precedence than fold expansion. Refer to the paper for more specifics.)
>
> The second part proposes that parameter pack operations, particularly
> slicing (as in the first part), but also (optionally) `sizeof...`,
> should also work on product types as well as packs. Critically, this
> means that the following would now be semantically equivalent:
>
> std::apply(foo, pt);
> foo([:]pt...);
>
> Please refer to the paper for motivating examples.
--
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/589276B2.1010706%40gmail.com.
--------------080309090707090004030800
Content-Type: text/prs.fallenstein.rst;
name="p0535r0-generalized-unpacking.rst"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: attachment;
filename="p0535r0-generalized-unpacking.rst"
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D
Generalized Unpacking and Parameter Pack Slicing
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D
:Document: P0535R0
:Date: 2017-02-01
:Project: ISO/IEC JTC1 SC22 WG21 Programming Language C++
:Audience: Evolution Working Group
:Author: Matthew Woehlke (mwoehlke.floss@gmail.com)
=2E. raw:: html
<style>
html { color: black; background: white; }
table.docinfo { margin: 2em 0; }
p, li { text-align: justify; }
li { margin-bottom: 0.5em; }
.lit { font-weight: bold; padding: 0 0.3em; }
.var { font-style: italic; padding: 0 0.3em; }
.opt::after { font-size: 70%; position: relative; bottom: -0.25em; co=
ntent: "opt"; }
</style>
=2E. role:: cpp(code)
:language: c++
=2E. role:: lit(code)
:class: lit
=2E. role:: var(code)
:class: var
=2E. role:: optvar(code)
:class: opt var
Abstract
=3D=3D=3D=3D=3D=3D=3D=3D
This proposal introduces two new, related concepts: "generalized unpackin=
g" (the conversion of product types to parameter packs) and parameter pac=
k slicing. These concepts use the same syntax and may be employed concurr=
ently.
=2E. contents::
Background
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
There is an increasing push in C++ to add interoperability between values=
and value sequences, exemplified by the recent addition of "structured b=
inding", :cpp:`std::apply`, and :cpp:`std::make_from_tuple` in C++17, and=
by proposals such as P0327_ that work toward expanding and clarifying th=
e concept of value sequences (using the term "product type") and P0341_ w=
hich proposes certain mechanisms for using product types. Similar feature=
s have long been present in other languages, with Python frequently held =
up as a representative example (see also `PEP 0448`_). While we feel that=
these represent steps in the right direction, there remain problems to b=
e solved.
Rationale
=3D=3D=3D=3D=3D=3D=3D=3D=3D
Parameter pack slicing, particularly single valued slicing, solves a know=
n problem when working with parameter packs. Several algorithms and ideas=
for working with parameter packs require the ability to select an item f=
rom a parameter pack by index.
Generalized unpacking greatly expands the ability to work with product ty=
pes. Although :cpp:`std::apply` and :cpp:`std::make_from_tuple` attempt t=
o fill some of these roles, their mere existence, and especially that the=
y are two separate functions despite serving conceptually identical purpo=
ses, is indicative of the usefulness of a language feature. Moreover, the=
se functions have significant limitations: they can only cover specific u=
se cases, they cannot perform slicing operations on their own, and they c=
annot be readily used where the desired argument list *includes* but does=
not *solely consist of* a single product type.
Although we could attempt to solve these issues independently, we believe=
it is better to approach them together.
Proposal
=3D=3D=3D=3D=3D=3D=3D=3D
We present our proposal in two parts. First, we present the proposed synt=
ax and examine its function in the context of parameter packs. Second, we=
extend the application of the proposed syntax to also incorporate "concr=
ete" product types.
Parameter Pack Slicing
----------------------
We propose to introduce a new prefix operator, :lit:`[`\ :var:`slicing_ex=
pression`\ :lit:`]`, which may be applied to an expression producing a pa=
rameter pack. The syntax of :var:`slicing_expression` shall be one of :va=
r:`index` or :optvar:`index`\ :lit:`:`\ :optvar:`index`, where each :var:=
`index` is a :cpp:`constexpr` of integer type. For the purposes of the fo=
llowing specification, also let :var:`pack_expression` be the operand of =
the slicing expression.
The first form shall select a *single* element of a pack, and shall yield=
this value as a single value (i.e. not as a new pack). For example, the =
expression :cpp:`[1]pack` shall yield the second value of the parameter p=
ack :cpp:`pack`. If the :var:`index` is negative, it shall first be added=
to :cpp:`sizeof...(`\ :var:`pack_expression`\ :cpp:`)`. If the index (af=
ter the preceding step, if applicable) is out of bounds, the expression s=
hall be ill-formed.
The second form shall return a *variable* slice of the parameter pack, an=
d shall yield this value as a new parameter pack. Both indices are option=
al and may be omitted. The first :var:`index` shall specify the index of =
the first pack element to yield. If omitted, the value :cpp:`0` shall be =
assumed. The second :var:`index` shall specify the *upper bound* on the i=
ndices to be yielded, meaning that the specified index is *not* included.=
If omitted, the value :cpp:`sizeof...(`\ :var:`pack_expression`\ :cpp:`)=
` shall be assumed. If either value is negative, it shall first be added =
to :cpp:`sizeof...(`\ :var:`pack_expression`\ :cpp:`)`. Each value shall =
then be clamped to the range [\ :cpp:`0`, :cpp:`sizeof...(`\ :var:`pack_e=
xpression`\ :cpp:`)`]. If, after normalization and clamping, the upper in=
dex is less than the lower index, an empty parameter pack shall be yielde=
d. (Note that this means that a variable slice is never ill-formed due to=
out of bounds index values.)
This can be represented in pseudo-code::
// let [lower:upper](pack) represent the complete slicing expression
size =3D sizeof...(pack);
if lower is unspecified:
lower =3D 0;
if upper is unspecified:
upper =3D size;
if lower < 0:
lower =3D size + lower;
if upper < 0:
upper =3D size + upper;
lower =3D bound(0, lower, size);
upper =3D bound(0, upper, size);
for (index =3D lower; index < upper; ++index)
yield [index]pack;
Note that the expressions :cpp:`[:]pack` and :cpp:`pack` are equivalent; =
that is, a slicing expression which uses the defaults for both the lower =
and upper indices shall produce the same parameter pack.
Generalized Unpacking
---------------------
By presenting slicing first, we may consider generalized unpacking to be =
an extension of parameter pack operations to work on product types. Speci=
fically, we propose that the above described slicing operator and :cpp:`s=
izeof...` be extended to accept product types as well as parameter packs.=
When used on a product type, the type is "unpacked" into a parameter pac=
k.
For example, given a product type :cpp:`t` of size 3, :cpp:`sizeof...(t)`=
would be well formed and equal to 3, and the expression :cpp:`[:]t` woul=
d expand to a parameter pack equivalent to :cpp:`get<0>(t), get<1>(t), ge=
t<2>(t)`. (While we use :cpp:`get<N>` here and throughout for illustrativ=
e purposes, this proposal would reflect any changes made to product type =
access. In particular, it should support all types that may be used in de=
composition declarations.) Moreover, as is usual for :cpp:`sizeof`, the a=
rgument here should be *unevaluated*.
Accordingly, :cpp:`[expr1]expr2` would be equivalent to :cpp:`get<expr1>(=
expr2)`; that is, a single value rather than a parameter pack.
Implementing this is straight forward; if a slicing operation or :cpp:`si=
zeof...` is used on an expression which is not a parameter pack, rather t=
han being an error, the compiler shall attempt to proceed as if the expre=
ssion produces a product type. (If this attempt also fails, then an error=
is raised, as usual.)
This makes possible uses like the following, which are not readily accomp=
lished using library-only solutions:
=2E. code:: c++
// let a1..a9 be single values
// let t1, t2 be product types ("tuple-like")
auto x =3D SomeType(a1, [:]t1..., [3:]t2..., a2);
foo([1:]t1..., a3, [0]t1);
// let v1, v2 be vector-like types of T that may or may not be an array=
, e.g.:
// std::array<int, N>
// Eigen::Vector3d
// QPoint
// struct Point { int x, y; }
auto manhattan_length =3D std::abs([:]v1) + ...;
auto manhattan_distance =3D std::abs([:]v1 - [:]v2) + ...;
auto dot =3D ([:]v1 * [:]v2) + ...;
Note also an important implication of both the above code and many of the=
examples to follow; namely, that we assign the slicing/unpacking operato=
r (prefix :cpp:`operator[]`) higher precedence than fold operator (postfi=
x :cpp:`operator...`).
Finally, we would be remiss if we failed to note one last reason why impl=
ementing a language feature that allows indexed access to product types i=
s useful: it can allow access to bitfield members. At this time, there is=
no way to implement :cpp:`get<N>` for an aggregate containing bitfield m=
embers that would allow assignment to those members. However, a language =
feature that operates in the same manner as decomposition declarations, a=
s our proposed feature would, can accomplish this. Thus, the following ex=
ample becomes possible, and has the intended effect:
=2E. code:: c++
struct Foo
{
int a : 4;
int b : 4;
};
Foo foo;
[0]foo =3D 7;
[1]foo =3D 5;
Although we would prefer an eventual resolution to this issue that allows=
bitfields to become first class citizens (e.g. the ability to return a b=
itfield reference or pass a bitfield reference as a parameter), our propo=
sed language feature would at least extend indexed access to product type=
s with bitfield members.
Additional Examples
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
Heads and Tails
---------------
It should be obvious that this solves problems alluded to by P0478_:
=2E. code:: c++
// Ugly and broken
void signal(auto... args, auto last)
{
// pass first 5 arguments to callback; ignore the rest
if constexpr (sizeof...(args) > 5)
return signal(args...);
else if constexpr (sizeof...(args) =3D=3D 4)
callback(args..., last);
else
callback(args...);
}
// Enormously better
void signal(auto... args)
{
// pass first 5 arguments to callback; ignore the rest
callback([:5]args...);
}
Note also that the above "ugly" version of the function has several issue=
s (which we have copied from its specification in P0478_\ R0):
- It cannot be invoked with zero arguments.
- When invoked recursively, there is a spurious :cpp:`return` statement.
- If fewer than 5 arguments are supplied to :cpp:`signal`, the last argum=
ent is unintentionally dropped.
The last point in particular is subtle and difficult to reason about, thu=
s providing an excellent illustration of why needing to write code like t=
his is bad. The version using our proposed feature is enormously cleaner =
and far easier to understand, and significantly reduces the chances of ma=
king such mistakes in the implementation. In addition, recursion is elimi=
nated entirely (which, given that the example is accepting parameters by-=
value, could be critically important if some arguments have non-trivial c=
opy constructors).
We can also improve the second example:
=2E. code:: c++
// Mostly okay
auto alternate_tuple(auto first, auto... middle, auto last)
{
if constexpr (sizeof...(items) <=3D 2)
return std::tuple(first, last, middle...);
else
return std::tuple_cat(std::tuple(first, last),
alternate_tuple(middle...));
}
// Better
auto alternate_tuple(auto... items)
{
if constexpr (sizeof...(items) < 3)
return std::tuple{items...};
else
return std::tuple{[0]items, [-1]items,
[:]alternate_tuple([1:-1]items...)...};
}
As with the previous example, our version solves a boundary case (in this=
instance, when fewer than two items are given) that is not handled by th=
e version given in P0478_. In particular, without slicing, one must imple=
ment an overload to handle such boundary cases, potentially resulting in =
duplicated code and the attendant increase in maintenance burden. With sl=
icing, we can trivially handle such boundary cases in the same function.
Divide-and-Conquer
------------------
The ability to slice parameter packs makes it possible to implement binar=
y divide-and-conqueror algorithms on parameter packs, which would be diff=
icult or impossible to achieve otherwise. Consider this example which sel=
ects the "best" element in a parameter pack:
=2E. code:: c++
auto best(auto const& first, auto const&... remainder)
{
if constexpr (sizeof...(remainder) =3D=3D 0)
return first;
else
return better_of(first, best(remainder...);
}
While this example is overly simplified, what if it was significantly mor=
e efficient if the function could be written to require only ``O(log N)``=
recursion rather than ``O(N)`` recursion? With slicing, this can be acco=
mplished easily:
=2E. code:: c++
auto best(auto const&... args)
{
constexpr auto k =3D sizeof...(args);
if constexpr (k =3D=3D 1)
return [0]args;
else
return better_of(best([:k/2]args...), best([k/2:]args...));
}
Note also that the above code no longer needs to accept the first argumen=
t separately.
Unpacking and Fold Expressions
------------------------------
Let's consider now some additional examples of how generalized unpacking =
allows us to write fold expressions on the elements of product types:
=2E. code:: c++
std::tuple<int> t1 { 1, 2, 3 };
std::tuple<int,int> t2 { 4, 5, 6 };
std::tuple<int,int,int> t3 { 7, 8, 9 };
auto tt =3D std::make_tuple(t1, t2, t3); // a tuple of tuples
f([:]tt ...); // f(t1, t2, t3);
f(g([:]tt) ...); // f(g(t1), g(t2), g(t3));
f(g([:]tt ...)); // f(g(t1, t2, t3));
f(g([:][:]tt ...) ...); // ill-formed
f(g([:][:]tt ... ...)); // ill-formed
Note that, due to the precedence we specified, the last two lines are ill=
-formed. In both cases, the second :cpp:`[:]` is redundant, resulting in =
an attempt to apply :cpp:`...` to something which is not a parameter pack=
=2E Note also that a consequence of this precedence is that :cpp:`[:]` ca=
nnot be used as the operator of a fold expression.
This leaves two relatively straight-forward cases that are not addressed =
purely by the proposed feature, but are nevertheless made significantly e=
asier with it:
=2E. code:: c++
// f(g(1,2,3), g(4,5,6), g(7,8,9));
f(std::apply(g, [:]tt)...);
// f(g(1, 2, 3, 4, 5, 6, 7, 8, 9));
f(g([:]std::tuple_cat([:]tt...)...));
f(std::apply(g, [:]tt...));
For the last example, we assume an extension to :cpp:`std::apply` to acce=
pt multiple product types which are "flattened" into the arguments for th=
e specified function. We are not proposing this here, merely showing an e=
xample of how the task could be accomplished.
Although this is effective, at least for the above examples, pack generat=
ors would provide a better solution for this and other more complicated p=
roblems. See `Future Direction`_ for further discussion.
Slicing Product Types
---------------------
It's harder to imagine generic uses for slicing product types, since prod=
uct types come in so very many varieties. However, we have already allude=
d to the case of rearranging elements in a product type as one possible u=
se. Another likely use case deals with linear algebra and geometry, parti=
cularly operations dealing with homogeneous vectors. Let us consider the =
simple example of converting a homogeneous vector to a normalized vector.=
Such an operation would normally be written out "longhand", and would be=
difficult to adapt to vectors of arbitrary dimension. Our proposed featu=
re allows us to write a simple and succinct implementation:
=2E. code:: c++
template <typename T, size_t N>
std::array<T, N-1> normalize(std::array<T, N> a)
{
return {[:-1]a / [-1]a...};
}
In some cases, it may be possible to write generic versions of such algor=
ithms making use of :cpp:`std::invoke`, but doing so is likely to require=
employing a lambda to receive the argument pack, and will almost certain=
ly be much more unwieldy than the simple, succinct syntax our proposal ma=
kes possible.
Improving :cpp:`std::apply`
---------------------------
The previous example postulated an extension to :cpp:`std::apply` to acce=
pt multiple product types. While this can of course be achieved already u=
sing :cpp:`std::tuple_cat`, avoiding unnecessary copies and/or temporary =
objects is awkward at best. The postulated extension should be able to av=
oid these problems. Using our proposed feature, we can show (forwarding o=
mitted for brevity) how this might be implemented:
=2E. code:: c++
namespace std
{
template <int n, typename Func, typename Args...>
auto apply_helper(Func func, Args... args)
{
// n is number of already-unpacked arguments
constexpr auto r =3D sizeof...(args) - n; // remaining tuples
if constexpr (r =3D=3D 0)
return func(args...);
auto&& t =3D [n]args;
auto k =3D sizeof...(t);
return apply_helper<n + k>(func, [:n]args, [:]t..., [n+1:]args);
}
template <typename Func, typename Tuples...>
auto apply(Func func, Tuples... tuples)
{
return apply_helper<0>(func, tuples);
}
}
Although this is feasible, and would ideally optimize down to a direct ca=
ll of the specified function with all of the tuple values extracted direc=
tly, it is not meant to imply that this is the only possible solution, no=
r necessarily even the *best* solution. In particular, we would again not=
e that pack generators would offer an even better solution to this specif=
ic problem. Rather, this example is intended to show how our proposed fea=
ture allows tail-recursive unpacking of multiple product types; in partic=
ular, without using a new tuple to wrap the values as they are unpacked.
Reversing a product type
------------------------
The above example inspires another function that is often cited as a use =
case: reversing the elements in a product type. As above, forwarding is o=
mitted for brevity:
=2E. code:: c++
template <int n, typename... Args>
auto reverse_tuple_helper(Args... args)
{
constexpr auto r =3D sizeof...(args) - n; // remaining elements
if constexpr (r < 2)
return make_tuple(args...);
return reverse_tuple_helper<n + 1>(args[:n]..., args[-1], args[n:-1].=
=2E.);
}
template <typename T>
auto reverse_tuple(T tuple)
{
return reverse_tuple_helper<0>([:]tuple...);
}
A more complicated implementation could reduce the number of template ins=
tantiations by about half, by swapping pairs of arguments starting with t=
he first and last and working inwards. This approach avoids the need for =
index sequences and can be applied to parameter packs without creation of=
a temporary tuple to hold the pack.
Static value table
------------------
It's not entirely unusual to have an array (often a C-style array) or oth=
er entity which holds static, immutable data which uses an initializer li=
st to set up the data. For example:
=2E. code:: c++
double sin64[] =3D {
_builtin_sin(2.0 * 0.0 * M_PI / 64.0),
_builtin_sin(2.0 * 1.0 * M_PI / 64.0),
_builtin_sin(2.0 * 2.0 * M_PI / 64.0),
_builtin_sin(2.0 * 3.0 * M_PI / 64.0),
// ...and so forth
At present, it is typically necessary to write out such data tables by ha=
nd (or to write a program to generate source code). Unpacking suggests an=
alternative approach:
=2E. code:: c++
template <size_t Size>
struct sin_table_t
{
public:
constexpr static size_t tuple_size()
{ return Size; }
template <size_t N> constexpr double get() const
{
return _builtin_sin(static_cast<double>(N) * K);
}
private:
constexpr static auto K =3D 2.0 * M_PI / static_cast<double>(Size);
};
double sin64[] =3D { [:](sin_table_t<64>{})... };
While this example still entails some boilerplate, it shows how unpacking=
makes it possible to define the elements of an initializer list using :c=
pp:`constexpr` functions.
Discussion
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
What is a "product type"?
-------------------------
This is an excellent question which deserves its own paper. P0327_ makes =
a good start. When we get to the point of specifying wording, this will n=
eed to be addressed; ideally, this will have happened in parallel. Some "=
working definitions" which may be used to help with consideration of this=
proposal are "types which define :cpp:`tuple_size` and :cpp:`get`", or "=
types to which decomposition declarations may be applied". While we have =
generally specified that the behavior of our proposed feature should mirr=
or that of decomposition declarations, we would like to see a more genera=
l specification of these issues.
Why combine these features?
---------------------------
We prefer to think of this proposal as not two separate features (paramet=
er pack slicing, generalized unpacking), but rather a single feature (pro=
duct type slicing) that works on *both* "concrete" product types and para=
meter packs. Seen in this light, the case for the feature is strengthened=
, as it presents a single syntax that solves multiple problems.
Why choose prefix :cpp:`operator[]`?
------------------------------------
Other alternatives that have been proposed or considered:
- :cpp:`t.N`, :cpp:`t~N`
While these work for at least the single value case, they are less cond=
ucive to slicing, nor are they as readily extended to generalized unpacki=
ng. The use of an integer in place of an identifier also seems unusual; w=
orse, there is a potential conflict when using a :cpp:`constexpr` express=
ion as the index (although this could be solved by enclosing the expressi=
on in ``()``\ s).
- :cpp:`t.[L:U]`, :cpp:`t~(L:U)`
These support slicing, but the syntax is starting to look rather strang=
e.
- :cpp:`^t...[L:U]`
This approach, based heavily on a suggestion by Bengt Gustafsson, intro=
duces indexing/slicing and unpacking as completely separate operations an=
d binds indexing/slicing to fold expansion:
.. code:: c++
pack...[i] // equivalent to our [i]pack...
pack...[l:u] // equivalent to our [l:u]pack...
^pt // equivalent to our [:]pt
^pt...[i] // equivalent to our [i]pt
sizeof...(^pt) // equivalent to our sizeof...(pt)
This has the advantage of being tightly coupled to expansion, and there=
by makes moot the difference between indexing (which produces a value) an=
d slicing (which produces a pack). However, this also precludes compositi=
on of slicing or indexing. Separating indexing/slicing from unpacking als=
o enforces a distinction between product types and parameter packs, which=
may or may not be desirable. It also results in more roundabout and verb=
ose syntax for indexed access to a product type.
The exact syntax for these features can be debated. We prefer prefix :cpp=
:`operator[]` because C++ programmers are already familiar with :cpp:`ope=
rator[]` as an indexing operator, which is essentially what we are propos=
ing (especially for the single value case), and because the proposed synt=
ax is very similar to Python, which will already be familiar to some C++ =
programmers. At the same time, the choice of a prefix as opposed to postf=
ix syntax makes it clear that the slicing operation |--| which we like to=
think of as *compile-time indexing* |--| is different from the usual *ru=
n-time indexing*. The proposed syntax also applies "naturally" to both pa=
rameter packs and product types, which gives us a single feature with bro=
ad applicability, rather than two entirely orthogonal features.
See also `What alternatives were considered?`_ for a discussion of altern=
atives which may achieve comparable operations but do not fit within the =
same general framework as our proposal.
Does this conflict with :cpp:`operator[](constexpr size_t)`?
------------------------------------------------------------
One "obvious" argument against product type slicing is that :cpp:`constex=
pr` parameters will make it irrelevant. We feel that this should not be g=
iven great weight against this proposal for several reasons:
- We don't have :cpp:`constexpr` parameters yet. At this time, we are not=
even aware of a proposal for such a feature.
- There are several interesting implications to a :cpp:`operator[](conste=
xpr size_t)`, including the (mostly) novel notion that the return type wi=
ll depend on the *function arguments*. It is unclear if this is desirable=
=2E
- Even if we get :cpp:`operator[](constexpr size_t)`, will such an operat=
or be implicitly generated for all product types? Given the difficulty wi=
th other "provide operators by default" proposals, this seems dubious at =
best.
- While our proposed feature may be equivalent to :cpp:`operator[]` for s=
ome types, this may not be the case for *all* types. For example, a span =
might present itself as a product type consisting of either a begin/end o=
r begin/size, while :cpp:`operator[]` provides indexed access to the span=
=2E A novel operator is appropriate unless we are prepared to *unconditio=
nally specify* that :cpp:`get<N>` and :cpp:`operator[](constexpr)` shall =
be synonyms.
- We would still require a language feature for indexed access to paramet=
er packs, and a postfix :cpp:`[]` may be ambiguous:
.. code:: c++
template <typename T, size_t N, typename... Vecs>
std::array<T, N> sum(Vecs... operands)
{
std::array<T, N> result;
for (int i =3D 0; i < N; ++i)
result[i] =3D operands[i] + ...;
}
- Such an operator still cannot provide slicing. See also `What alternati=
ves were considered?`_
Our proposed language feature avoids these issues by being clearly distin=
ct from existing :cpp:`operator[]`; it is in essence a novel operator. Th=
is is especially salient in the case of multi-valued slicing / unpacking,=
but also serves to make it more obvious to the user that a language feat=
ure is being employed rather than a traditional operator function.
Doesn't adding another operator hurt teachability?
--------------------------------------------------
Obviously, *any* new feature is something new to teach. The major concern=
, of course, is that we have two ways of doing "the same thing". However,=
this is already the case; we already may have both :cpp:`get<N>` and :cp=
p:`operator[]` for a type. Critically, we are *not* adding a third operat=
ion; our proposed operator is *always* a synonym for :cpp:`get<N>` (if it=
exists). It would be better to think of this proposal as *replacing* the=
spelling of product type indexed access, with :cpp:`get<N>` being the cu=
stomization point for the same. Thus, :cpp:`[i]pt` and :cpp:`get<i>(pt)` =
are equivalent in much the way that :cpp:`a + b` and :cpp:`a.operator+(b)=
` are equivalent. If this proposal is accepted, we expect that writing th=
e latter of each case will become similarly rare.
Does this make :cpp:`std::apply` (and :cpp:`std::make_from_tuple`) obsole=
te?
-------------------------------------------------------------------------=
---
No. There will almost certainly remain cases where :cpp:`std::apply` and/=
or :cpp:`std::make_from_tuple` are useful; for example, when using the op=
eration as a functor that gets passed as an argument, or when expansions =
are nested. In fact, we use :cpp:`std::apply` in at least one of the prec=
eding examples *in conjunction with* our proposed feature.
That said, we do expect that *most* uses of :cpp:`std::apply` and :cpp:`s=
td::make_from_tuple` can be replaced with the use of this feature.
Are "dead" accesses to product type value elided?
-------------------------------------------------
Consider the following code:
=2E. code:: c++
// let t be a product type ("tuple-like") of size 3
auto x =3D [1]t;
What code is actually generated by the above?
=2E. code:: c++
// option 1
[[maybe_unused]] get<0>(t);
auto x =3D get<1>(t);
[[maybe_unused]] get<2>(t);
// option 2
auto x =3D get<1>(t);
In most cases, the question should be irrelevant; the compiler will elimi=
nate the superfluous calls to :cpp:`get` as accomplishing nothing. Howeve=
r, if :cpp:`get` has side effects (however much we might be inclined to c=
onsider that poor design), this could matter.
Certainly in the above example, we believe that the compiler should elide=
the "superfluous" value accesses, as this feels like the most natural co=
nsequence of combining the unpacking and slicing operations. A more inter=
esting question, which we believe should be open to committee input, is w=
hat to do if slicing and unpacking are explicitly separated, as in :cpp:`=
[1][:]t`. While our inclination is that this form should be exactly equiv=
alent to :cpp:`[1]t`, an argument could be made that writing out the oper=
ations separately implies that the programmer intends for each value of :=
cpp:`t` to be accessed, with any resulting side effects incurred, before =
reducing the resulting parameter pack to only the value at index ``1``.
If we consider an initializer list to be a product type, conceivably a us=
er desiring side effects could obtain them by writing :cpp:`[1]{[:]t...}`=
, which makes the intent to evaluate all values of :cpp:`t` prior to sele=
cting a single value even more explicit.
(Note that one strong reason to consider :cpp:`[1][:]pt` and :cpp:`[1]pt`=
equivalent is for cases when the user actually writes something like :cp=
p:`[:n][i:]pt`, i.e. ':cpp:`n` elements of :cpp:`pt` starting with index =
:cpp:`i`'. In this case, evaluation of all indices starting with :cpp:`i`=
is not necessarily desired, but restructuring the code to avoid this req=
uires a more complicated expression that is especially difficult if :cpp:=
`i` and/or :cpp:`n` are expressions. Introducing an exception would make =
this feature more difficult to teach.)
How does unpacking interact with temporaries?
---------------------------------------------
Consider the following code:
=2E. code:: c++
// let foo() be a function returning a newly constructed product type
bar([:]foo()...);
What does this mean with respect to object lifetime? Obviously, we do not=
want for :cpp:`foo()` to be :cpp:`sizeof...(foo())` times. Rather, the c=
ompiler should internally generate a temporary, whose lifetime shall be t=
he same as if the unpacked expression had not been subject to unpacking.
What happens if the indexing expression contains a pack?
--------------------------------------------------------
Consider the following example:
=2E. code:: c++
// let x be a pack of integers
// let p be a pack of values
foo([x]p...);
What does this mean? Indexing is specified as having higher precedence th=
an expansion, but the indexing expression is itself a pack. The "easy" an=
swer is to make this an error (the indexing expression is not a :cpp:`con=
stexpr` integer, as required), but one could also argue that expansion in=
this case should occur first, which would make the code equivalent to:
=2E. code:: c++
foo([([0]x)]([0]p), [([1]x)]([1]p), ..., [([N]x)]([N]p));
We are inclined to take the easy answer and make this ill-formed. This le=
aves room for a future proposal to give such code meaning, should we ever=
desire to do so.
What about ambiguity with lambda captures?
------------------------------------------
A lambda capture is required to be a variable in the current scope. As su=
ch, the compiler can determine if a :cpp:`[` starts a lambda capture or a=
slicing expression by parsing at most three additional tokens. If the fi=
rst token following the :cpp:`[` is not a variable eligible for lambda ca=
pture (for example, an integer literal), then the :cpp:`[` starts a slici=
ng expression. If the first token matches an in-scope (and :cpp:`constexp=
r`) variable name, and the second token is not a :cpp:`,`, then the :cpp:=
`[` starts a slicing expression. In all other cases, the :cpp:`[` shall b=
e taken to start a lambda capture, as in current C++. (If the first token=
is :cpp:`&`, the preceding rules may be applied with the token counts sh=
ifted by 1. However, this assumes that there exists a case where unary :c=
pp:`operator&` is :cpp:`constexpr`. This may not be reasonable, in which =
case :cpp:`[&` would always indicate a lambda capture, and at most only t=
wo tokens following :cpp:`[` must be parsed.)
Consider the following example:
=2E. code:: c++
constexpr int a =3D ...;
[a]t;
By the above logic, this would be ill-formed. Although a slicing expressi=
on is intended, the compiler would be unable to disambiguate from a lambd=
a until after the :cpp:`]`, and following the above logic, the statement =
is parsed as a lambda. Such an expression calls for disambiguation:
=2E. code:: c++
constexpr int a =3D ...;
[(a)]t;
The addition of parentheses does not change the intended meaning of the s=
tatement, but precludes the statement from being parsed as a lambda captu=
re. We believe that this is an acceptable trade-off to prevent unreasonab=
le complexity in selecting between a slicing expression and a lambda capt=
ure.
Note also:
=2E. code:: c++
template <int n> auto get_and_apply(auto func, auto... items)
{
return func([n]args);
}
Although this example appears at first to be the same as the preceding ex=
ample, :cpp:`n` here is a template parameter and is not eligible for lamb=
da capture, so the expression is parsed as a slicing expression instead (=
as intended). Again, this seems like a reasonable trade-off, but we would=
be amenable to requiring parentheses in all cases where the index-expres=
sion is just an identifier.
An alternative approach, albeit one requiring additional look-ahead, is t=
o consider the token following the closing :cpp:`]`. If the token is not =
:cpp:`(`, then we have a slicing expression. If it is :cpp:`(` and the ne=
xt token is *not* a type name, then we have a slicing expression. Otherwi=
se, we have a lambda capture. This may be more robust, at the cost of bei=
ng more difficult to implement in compilers.
Should out-of-bounds access be an error?
----------------------------------------
This is a reasonable question. Consider:
=2E. code:: c++
void foo(args...) { bar(args[:3]...); }
foo(1, 2);
In the above, `foo` asks for *up to* the first 3 elements of a pack, but =
in the invocation shown, the pack only has two elements. Should this be a=
n error? On the one hand, experience with Python suggests that silently t=
runcating to the available range has many uses, and where this is not int=
ended, a :cpp:`static_assert` could be used to ensure the size of the pac=
k is as expected. On the other, :cpp:`constexpr` forms of :cpp:`std::min`=
and :cpp:`std::max`, or simply writing out ternary expressions, could be=
used to emulate this behavior, which might make programmer intent more c=
lear.
While we are inclined to the former position, with the behavior as presen=
ted in this paper, this does not represent a hard position, and we would =
welcome committee input on this matter.
Note that this only applies to slicing. Out of bounds *indexing* should c=
ertainly be an error.
Why choose trailing index?
--------------------------
The choice of the second value as a non-inclusive index, rather than a co=
unt, was made for consistency with existing convention (specifically, Pyt=
hon), because it is consistent with counting indices given a lower and up=
per bound, and because it simplifies the computation of the upper index w=
hen a negative value is given.
It is also worth noting that more complicated index expressions may be us=
ed to obtain a first-and-count slice using lower-until-upper notation or =
vice versa. More importantly, however, a first-and-count slice may be obt=
ained like :cpp:`[:count][first:]pack`, but obtaining a lower-until-upper=
slice with first-and-count syntax is more verbose.
Why extend :cpp:`sizeof...`?
----------------------------
The short answer is "symmetry". It seems logical to us that if slicing wo=
rks on both parameter packs and "concrete" product types that :cpp:`sizeo=
f...` should do likewise. However, this modification could be dropped wit=
hout significantly harming the proposal.
Can't we use a purely library solution?
---------------------------------------
No. While it may be possible to implement a standardized library function=
to extract a *single* element from a parameter pack, slicing requires *s=
ome* form of language solution (see also next question), or else the crea=
tion of temporary objects that will only be destroyed again immediately. =
(Additionally, we dislike any solution that creates a temporary product t=
ype because it is difficult for the user to control what type is used for=
this purpose. This is also why we dislike using a library function to sl=
ice product types. By producing a parameter pack, the pack can be used di=
rectly when that is desired, or used to construct a product type of the u=
ser's choice as needed.) A library solution would also be much more verbo=
se, and may result in poorer code generation, whereas language level slic=
ing of parameter packs is trivially accomplished by the compiler.
What alternatives were considered?
----------------------------------
There are at least three possible alternatives that could provide feature=
s similar to generalized unpacking, as proposed here. The first alternati=
ve is first class support for multiple return values, where such are trea=
ted as parameter packs. The second is modifying structured binding (which=
we prefer to call "name-binding unpacking", for symmetry with "generaliz=
ed unpacking") to support specifying a parameter pack as one of the unpac=
ked values. The third is to introduce parameter pack generators.
- First class support for multiple return values (which is effectively pr=
oposed by P0341_) is an ambitious feature with assorted difficulties (see=
next question). Moreover, if P0536_ is accepted, the need for true first=
class multiple return values would be significantly lessened.
- Modifying name-binding unpacking (e.g. :cpp:`auto&& [x, p..., y] =3D t;=
`) is likewise a language change of similar caliber to what we propose, w=
ith the added drawback of requiring additional declarations for many use =
cases.
- Parameter pack generation is interesting (in fact, we would like to see=
parameter pack generation *in addition* to this proposal), but still req=
uires the ability to extract a single element from a pack.
All of these would require greater verbosity for even simple use cases.
We believe that our proposal is the best solution, as it solves a crucial=
need not addressed by these alternatives (extracting a single value from=
a parameter pack) and further leverages that syntax to maximum versatili=
ty with minimal overhead compared to the minimum possible functionality.
We have yet to see a competing direction that can offer comparable functi=
onality with comparable complexity, even ignoring those parts of competin=
g directions which would have wider applicability (e.g. :cpp:`constexpr` =
function parameters). Every competing direction has, at some point, neces=
sarily proposed some feature of similar or greater complexity which serve=
s only to provide a feature that our proposal would already provide, and =
*every* competing direction involves much more "wordiness" for any of the=
use cases our proposal would address.
How does this relate to P0341_?
-------------------------------
We would be remiss to not discuss P0341_, especially in light of our prop=
osed generalized unpacking feature. Leaving aside various concerns as far=
as returning parameter packs (which are also discussed in P0536_), gener=
alized unpacking obviates a major use case for some of the features propo=
sed by P0341_. In particular, P0341_ gives this example:
=2E. code:: c++
<double, double> calculateTargetCoordinates();
double distanceFromMe(double x, double y);
void launch() {
if(distanceFromMe(calculateTargetCoordinates()...))
getOuttaHere();
}
The utility of being able to invoke the postulated :cpp:`distanceFromMe` =
function taking two parameters is obvious. However, the solution proposed=
by P0341_ is strictly limited in that it requires that the function prov=
iding the input values |--| :cpp:`calculateTargetCoordinates` |--| must p=
rovide them as a parameter pack. Moreover, it is not obvious at the point=
of use that :cpp:`calculateTargetCoordinates` returns a parameter pack r=
ather than a regular type.
Generalized unpacking provides a much better solution:
=2E. code:: c++
std::tuple<double, double> calculateTargetCoordinates();
double distanceFromMe(double x, double y);
void launch() {
if(distanceFromMe([:]calculateTargetCoordinates()...))
getOuttaHere();
}
The return type of :cpp:`calculateTargetCoordinates` is a regular type, a=
nd we can call :cpp:`distanceFromMe` on any product type value that can c=
onvert (or be sliced) to a pair of :cpp:`double`\ s.
Another issue which concerns us with P0341_, or any proposal for function=
s returning parameter packs, is the ambiguity it introduces. Consider the=
following statement:
=2E. code:: c++
auto x =3D foo();
At present, this is value for virtually anything that :cpp:`foo()` might =
return. If we allow parameter packs as return types, this will no longer =
be the case; users will always be uncertain if a particular expression yi=
elds a single object, or a parameter pack. If we attempt to solve this by=
allowing parameter packs to be treated as single objects, we are piling =
on additional language changes, on top of which one must ask why paramete=
r packs |--| being objects, like many other types |--| should be given un=
iquely special treatment in fold expressions. This could be especially co=
nfusing to novice readers:
=2E. code:: c++
auto x =3D foo();
auto y =3D x + ...; // why can 'x' be used in a fold expression?
At least with parameter packs as they exist today, it is obvious at the d=
eclaration site when an identifier names a parameter pack. Using a new sy=
ntax to create parameter packs from product types provides a similarly ob=
vious indicator when a parameter pack comes into being.
How does this relate to P0478_?
-------------------------------
After picking on their examples, it would be unfair if we did not follow =
up by asking if our proposed feature makes P0478_ unnecessary. As with :c=
pp:`std::apply`, we feel that the answer is "not necessarily", even thoug=
h our feature significantly reduces the need for P0478_. However, there a=
re two use cases for combining pack and non-pack arguments. One case, whi=
ch our proposal addresses in a significantly better manner, is artificial=
separation as a means for slicing parameter packs. The example we decons=
tructed above, as well as the many functions of the form :cpp:`T first, A=
rgs... remainder`, clearly fall into this category. In these cases, this =
artificial decomposition of the argument list is detrimental to the clari=
ty of the function's interface, and as shown can lead to implementation b=
ugs.
Another case, however, is where the separation is non-artificial; where, =
for whatever reason, a function accepts a variadic argument pack followed=
by one or more arguments that are logically unrelated to the pack. For s=
uch cases, P0478_ would provide improved clarity at the interface level, =
as well as the ability to specify (or at least, separately name) types fo=
r the trailing arguments.
That said, in light of our proposed feature, it may well be that a much m=
ore compelling rationale for P0478_ would be desired in order for that fe=
ature to be accepted.
Future Direction
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
Complex Ordering
----------------
This feature is not intended to solve all cases of value sequence composi=
tions and decompositions by itself. We specifically are not attempting to=
provide a language mechanism for reversing a value sequence, selecting i=
ndices (e.g. every other item) from a value sequence, or interleaving val=
ue sequences. We believe that there is significant room for library featu=
res to bring added value to this area. Such features would likely leverag=
e this feature under the covers. (Parameter pack generation, which as not=
ed is a feature we would like to see, almost certainly would use at least=
single-value indexing into parameter packs.)
Interaction with Name-Binding Unpacking
---------------------------------------
As stated several times, this feature is intended to continue in a direct=
ion first taken by name-binding unpacking. Despite that, combining these =
features presents an interesting challenge. Consider:
=2E. code:: c++
auto [a, b] =3D [:2]pt;
auto [a, b] =3D {[:2]pt...};
It seems natural to desire that one or both of these syntaxes should be p=
ermitted, but at this time (even with full adoption of this proposal as p=
resented), both are ill-formed. The latter possibly will become valid if =
and when general product type access is extended to initializer lists, wi=
th the assumption that such extension will include modification of name-b=
inding unpacking to work with any product type. However, there are potent=
ial lifetime issues involved. For this reason and others, it may be inter=
esting to extend name-binding unpacking to also work directly with parame=
ter packs, with the added stipulation that a product type converted to a =
parameter pack is "pass through" when appearing as the RHS of an name-bin=
ding unpacking statement; that is, the name-binding unpacking would be aw=
are of the original product type for the purpose of object lifetime. We d=
o not feel that this feature is necessary initially, but would recommend =
a follow-up paper if the feature proposed is accepted.
Pack Generators "Lite"
----------------------
In the `Static value table`_ example, we showed how to create a "product =
type" that exists solely to be unpacked and used as a value generator. Th=
is involved some boilerplate code. From the version of the example given,=
it should be readily apparent how one might rewrite the example as follo=
ws:
=2E. code:: c++
auto generate_sin64 =3D [](size_t n) {
return _builtin_sin(2.0 * M_PI * static_cast<double>(n) / 64.0); }
double sin64[] =3D {
[:](std::generate_pack_t<64, generate_sin64>{})... };
Here we show how a standard library type might be provided to take care o=
f most of the boilerplate in order to allow the direct conversion of a la=
mbda to a parameter pack. This lacks the expressive power of full pack ge=
nerators, and makes it rather painfully obvious that we'd like to have :c=
pp:`constexpr` parameters, but despite these limitations, the possibiliti=
es are interesting.
Acknowledgments
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
We wish to thank everyone on the ``std-proposals`` forum that has contrib=
uted over the long period for which this has been marinating. We also wis=
h to thank everyone that worked to bring decomposition declarations to C+=
+17, as well as the authors of all cited papers for their contributions t=
o this field.
References
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
=2E. _N4235: http://wg21.link/n4235
* N4235_ Selecting from Parameter Packs
http://wg21.link/n4235
=2E. _P0222: http://wg21.link/p0222
* P0222_ Allowing Anonymous Structs as Return Values
http://wg21.link/p0222
=2E. _P0311: http://wg21.link/p0311
* P0311_ A Unified Vision for Manipulating Tuple-like Objects
http://wg21.link/p0311
=2E. _P0327: http://wg21.link/p0327
* P0327_ Product Types Access
http://wg21.link/p0327
=2E. _P0341: http://wg21.link/p0341
* P0341_ Parameter Packs Outside of Templates
http://wg21.link/p0341
=2E. _P0478: http://wg21.link/p0478
* P0478_ Template argument deduction for non-terminal function parameter =
packs
http://wg21.link/p0478
=2E. _P0536: http://wg21.link/p0536
* P0536_ Implicit Return Type and Allowing Anonymous Types as Return Valu=
es
http://wg21.link/p0536
=2E. _PEP 0448: https://www.python.org/dev/peps/pep-0448
* `PEP 0448`_ Additional Unpacking Generalizations
https://www.python.org/dev/peps/pep-0448
=2E. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..=
.. ..
=2E. |--| unicode:: U+02014 .. em dash
=2E. kate: hl reStructuredText
--------------080309090707090004030800
Content-Type: text/html; charset=UTF-8;
name="p0535r0-generalized-unpacking.html"
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
filename="p0535r0-generalized-unpacking.html"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--------------080309090707090004030800--
.
Author: Barry Revzin <barry.revzin@gmail.com>
Date: Wed, 1 Feb 2017 17:43:08 -0800 (PST)
Raw View
------=_Part_45_1389320722.1485999788530
Content-Type: multipart/alternative;
boundary="----=_Part_46_1486105214.1485999788530"
------=_Part_46_1486105214.1485999788530
Content-Type: text/plain; charset=UTF-8
On Wednesday, February 1, 2017 at 6:00:54 PM UTC-6, Matthew Woehlke wrote:
>
> I'm posting an update, since there have been non-trivial changes to the
> examples and some discussion questions, partly thanks to some in depth
> discussions with Bengt Gustafsson.
>
> Again, feedback appreciated, especially on the examples and discussion
> points. (The original summary, for context, is quoted below.)
>
> Matthew
>
>
Just wondering. Who is the "we"? The paper is all in first-person plural,
but you're the only author listed.
--
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/9264831d-5008-4e5e-8c8e-64a5bd4c2756%40isocpp.org.
------=_Part_46_1486105214.1485999788530
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">On Wednesday, February 1, 2017 at 6:00:54 PM UTC-6, Matthe=
w Woehlke wrote:<blockquote class=3D"gmail_quote" style=3D"margin: 0;margin=
-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;">I'm postin=
g an update, since there have been non-trivial changes to the
<br>examples and some discussion questions, partly thanks to some in depth
<br>discussions with Bengt Gustafsson.
<br>
<br>Again, feedback appreciated, especially on the examples and discussion
<br>points. (The original summary, for context, is quoted below.)
<br>
<br>Matthew
<br><br></blockquote><div><br></div><div>Just wondering. Who is the "w=
e"? The paper is all in first-person plural, but you're the only a=
uthor listed.=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" 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/9264831d-5008-4e5e-8c8e-64a5bd4c2756%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/9264831d-5008-4e5e-8c8e-64a5bd4c2756=
%40isocpp.org</a>.<br />
------=_Part_46_1486105214.1485999788530--
------=_Part_45_1389320722.1485999788530--
.
Author: Matthew Woehlke <mwoehlke.floss@gmail.com>
Date: Thu, 2 Feb 2017 10:17:16 -0500
Raw View
On 2017-02-01 20:43, Barry Revzin wrote:
> Just wondering. Who is the "we"? The paper is all in first-person plural,
> but you're the only author listed.
It's stylistic; authorial "we" is more formal than first-person
singular, and feels more appropriate to proposal writing. (At least IMHO.)
See also https://en.wikipedia.org/wiki/We.
--
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.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/58934D7C.5070803%40gmail.com.
.
Author: mihailnajdenov@gmail.com
Date: Thu, 28 Dec 2017 04:37:20 -0800 (PST)
Raw View
------=_Part_19227_1078520193.1514464641078
Content-Type: multipart/alternative;
boundary="----=_Part_19228_659042049.1514464641079"
------=_Part_19228_659042049.1514464641079
Content-Type: text/plain; charset="UTF-8"
Hello, the syntax has some major problems
std::tuple<int, int, int> t;
[0][1]t;
Should I read left to right or right to left?
I know the answer - right to left. However - we are back in the reverse
invocation of get<0>(get<1>())!
Even worse:
[0]t[1];
Is it a tuple element, which is an array or an array element which is a
tuple?!?
Sure, there is an answer, based on operator precedence, but one must *know*
and *evaluate* the precedence in his head to be able to read the code.
Ironically even get<> is better in that case!
As I wrote an year ago*, the answer is to use the dot to enter
subobjects-access, not unlike it was used for decades now.
t.[0].[1]; *//< we are digging in! The natural way. Orthogonal
to s.field.field;*
t.[0][1]; *//< sure the 0 element of a tuple(-like) is an array*
The moment we press the dot we signal that "we open the type".
After we open it *we can index it, slice it or expand it without ambiguity *
t.[0];
t.[1:];
f(t...); //< note, just ..., no ambiguity. equivalent of t....
As for an advanced example:
template<template<class...> class... Ts> //< sizeof...(Ts) is N
void f()
{
func(Ts. ...) ...; //< Param is expanded tuple, func called N times.
Note, a dot to prevent ambiguity!
func(Ts.) ...; //< Expand each tuple element as a single param and
call func N times. Note size must match!
func(Ts) ...; //< Param is the unexpanded tuple, call func N times
with it
func(Ts...); //< Param is N unexpanded tuples, call func once
}
Note the *subscription syntax is only needed when we need a subscript* -
when we index or slice.
Of course, we can do both
f(t.[1].[1:4]...); //< dig by index, slice, expand!
An empty slice will only mean copy all, it is not used for pack access (we
use dot for that)
auto t2 = t.[:]; //< We open the door an pour out everything. Same as t2 =
t1;
*https://groups.google.com/a/isocpp.org/forum/#!searchin/std-proposals/sugar/std-proposals/n-44mMGbCv0/nMeD8_YzBwAJ
--
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/414ca3f0-06ae-4988-a46d-a21c135d8361%40isocpp.org.
------=_Part_19228_659042049.1514464641079
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><div>Hello, the syntax has some major problems</div><div><=
br></div><div><span style=3D"display: inline !important; float: none; backg=
round-color: transparent; color: rgb(34, 34, 34); font-family: courier new,=
monospace; font-size: 13px; font-style: normal; font-variant: normal; font-=
weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-dec=
oration: none; text-indent: 0px; text-transform: none; -webkit-text-stroke-=
width: 0px; white-space: normal; word-spacing: 0px;">std::tuple<int, int=
, int> t;</span></div><div><span style=3D"display: inline !important; fl=
oat: none; background-color: transparent; color: rgb(34, 34, 34); font-fami=
ly: courier new,monospace; font-size: 13px; font-style: normal; font-varian=
t: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align=
: left; text-decoration: none; text-indent: 0px; text-transform: none; -web=
kit-text-stroke-width: 0px; white-space: normal; word-spacing: 0px;"><br></=
span></div><div><font face=3D"courier new,monospace">[0][1]t;=C2=A0</font><=
/div><div><font face=3D"courier new,monospace"><br></font></div><div>Should=
I read left to right or right to left?=C2=A0</div><div>I know the answer -=
right to left. However - we are back in the reverse invocation of get<0=
>(get<1>())!</div><div><br></div><div>Even worse:</div><div><br></=
div><div><font face=3D"courier new,monospace">[0]t[1];</font></div><div><fo=
nt face=3D"courier new,monospace"><br></font></div><div>Is it a tuple eleme=
nt, which is an array or an array element which is a tuple?!?</div><div><br=
></div><div>Sure, there is an answer, based on operator precedence, but one=
must <i>know</i> and <i>evaluate</i> the <span style=3D"display: inline !i=
mportant; float: none; background-color: transparent; color: rgb(34, 34, 34=
); font-family: "Arial","Helvetica",sans-serif; font-si=
ze: 13px; font-style: normal; font-variant: normal; font-weight: 400; lette=
r-spacing: normal; orphans: 2; text-align: left; text-decoration: none; tex=
t-indent: 0px; text-transform: none; -webkit-text-stroke-width: 0px; white-=
space: normal; word-spacing: 0px;">precedence in his head to be able to rea=
d the code</span>.</div><div>Ironically even get<> is better in that =
case!</div><div><br></div><div><br></div><div><br></div><div>As I wrote an =
year ago*, the answer is to use the dot to enter subobjects-access, not unl=
ike it was used for decades now.=C2=A0</div><div><br></div><div><br></div><=
div><font face=3D"courier new,monospace">t.[0].[1]; <i>//< we are diggin=
g in! The natural way. Orthogonal to=C2=A0<span style=3D"text-align: left; =
color: rgb(34, 34, 34); text-transform: none; text-indent: 0px; letter-spac=
ing: normal; font-family: courier new,monospace; font-size: 13px; font-vari=
ant: normal; font-weight: 400; word-spacing: 0px; display: inline !importan=
t; white-space: normal; orphans: 2; float: none; -webkit-text-stroke-width:=
0px; background-color: transparent;">s.field.field;</span></i></font></div=
><div><br></div><div><font face=3D"courier new,monospace"><br></font></div>=
<div><font face=3D"courier new,monospace">t.[0][1]; <i>//< sure the 0 el=
ement of a tuple(-like) is an array</i></font></div><div><br></div><div><br=
></div><div>The moment we press the dot we signal that "we open the ty=
pe". </div><div><br></div><div>After we open it <i>we can index it, sl=
ice it or expand it without ambiguity=C2=A0</i></div><div><i><br></i></div>=
<div><font face=3D"courier new,monospace">=C2=A0=C2=A0</font></div><div><fo=
nt face=3D"courier new,monospace">=C2=A0 t.[0];</font></div><div><font face=
=3D"courier new,monospace">=C2=A0 t.[1:];</font></div><div><font face=3D"co=
urier new,monospace">=C2=A0 f(t...); //< note, just ..., no ambiguity. e=
quivalent of t....=C2=A0</font></div><div><font face=3D"courier new"><br></=
font></div><div><font face=3D"courier new">=C2=A0 As for an advanced exampl=
e:</font></div><div><font face=3D"courier new,monospace"><br></font></div><=
div><font face=3D"courier new,monospace" size=3D"2">=C2=A0=C2=A0=C2=A0 temp=
late<template<class...> class... Ts> //< sizeof...(Ts) is N<=
br>=C2=A0=C2=A0=C2=A0 void f()<br>=C2=A0=C2=A0=C2=A0 {<br>=C2=A0=C2=A0=C2=
=A0=C2=A0=C2=A0 func(Ts. ...) ...; //< Param is expanded tuple, func cal=
led N times. Note, a dot to prevent ambiguity!=C2=A0</font></div><div><font=
face=3D"courier new,monospace" size=3D"2">=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0 f=
unc(Ts.) ...; //< Expand each tuple element as a single param and call f=
unc N times. Note size must match!</font></div><div><font face=3D"courier n=
ew,monospace" size=3D"2">=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0 func(Ts) ...; //<=
; Param is the unexpanded tuple, call func N times with it</font></div><div=
><font face=3D"courier new,monospace" size=3D"2">=C2=A0=C2=A0=C2=A0=C2=A0=
=C2=A0 func(Ts...); //< Param is N unexpanded tuples, call func once<br>=
=C2=A0=C2=A0=C2=A0 }</font></div><div><font face=3D"courier new,monospace" =
size=3D"2"><br></font></div><div><br></div><div>Note the <i>subscription sy=
ntax is only needed when we need a subscript</i> - when we index or slice.<=
/div><div><i><br></i></div><div>Of course, we can do both</div><div><br></d=
iv><div><font face=3D"courier new,monospace">f(t.[1].[1:4]...); //< dig =
by index, slice, expand!</font></div><div><font face=3D"courier new"><br></=
font></div><div><font face=3D"arial,sans-serif">An empty slice will only me=
an copy all, it is not used for pack access (we use dot for that)</font></d=
iv><div><font face=3D"arial,sans-serif"><br></font></div><div><font face=3D=
"courier new">auto t2 =3D t.[:]; //< We open the door an pour out everyt=
hing.<span style=3D"display: inline !important; float: none; background-col=
or: transparent; color: rgb(34, 34, 34); font-family: courier new; font-siz=
e: 13px; font-style: normal; font-variant: normal; font-weight: 400; letter=
-spacing: normal; orphans: 2; text-align: left; text-decoration: none; text=
-indent: 0px; text-transform: none; -webkit-text-stroke-width: 0px; white-s=
pace: normal; word-spacing: 0px;"> Same as t2 =3D t1;</span></font></div><d=
iv><br></div><div><br></div><div><br></div><div>*https://groups.google.com/=
a/isocpp.org/forum/#!searchin/std-proposals/sugar/std-proposals/n-44mMGbCv0=
/nMeD8_YzBwAJ</div><div><br></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" 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/414ca3f0-06ae-4988-a46d-a21c135d8361%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/414ca3f0-06ae-4988-a46d-a21c135d8361=
%40isocpp.org</a>.<br />
------=_Part_19228_659042049.1514464641079--
------=_Part_19227_1078520193.1514464641078--
.
Author: mihailnajdenov@gmail.com
Date: Fri, 29 Dec 2017 01:45:06 -0800 (PST)
Raw View
------=_Part_26616_1435653405.1514540706750
Content-Type: multipart/alternative;
boundary="----=_Part_26617_724266245.1514540706751"
------=_Part_26617_724266245.1514540706751
Content-Type: text/plain; charset="UTF-8"
On Thursday, December 28, 2017 at 2:37:21 PM UTC+2, mihailn...@gmail.com
wrote:
>
> Hello, the syntax has some major problems
>
> std::tuple<int, int, int> t;
>
> [0][1]t;
>
> Should I read left to right or right to left?
> I know the answer - right to left. However - we are back in the reverse
> invocation of get<0>(get<1>())!
>
> Even worse:
>
> [0]t[1];
>
> Is it a tuple element, which is an array or an array element which is a
> tuple?!?
>
> Sure, there is an answer, based on operator precedence, but one must
> *know* and *evaluate* the precedence in his head to be able to read the
> code.
> Ironically even get<> is better in that case!
>
>
>
> As I wrote an year ago*, the answer is to use the dot to enter
> subobjects-access, not unlike it was used for decades now.
>
>
> t.[0].[1]; *//< we are digging in! The natural way. Orthogonal
> to s.field.field;*
>
>
> t.[0][1]; *//< sure the 0 element of a tuple(-like) is an array*
>
>
> The moment we press the dot we signal that "we open the type".
>
> After we open it *we can index it, slice it or expand it without
> ambiguity *
>
>
> t.[0];
> t.[1:];
> f(t...); //< note, just ..., no ambiguity. equivalent of t....
>
> As for an advanced example:
>
> template<template<class...> class... Ts> //< sizeof...(Ts) is N
> void f()
> {
> func(Ts. ...) ...; //< Param is expanded tuple, func called N times.
> Note, a dot to prevent ambiguity!
> func(Ts.) ...; //< Expand each tuple element as a single param and
> call func N times. Note size must match!
> func(Ts) ...; //< Param is the unexpanded tuple, call func N times
> with it
> func(Ts...); //< Param is N unexpanded tuples, call func once
> }
>
>
> Note the *subscription syntax is only needed when we need a subscript* -
> when we index or slice.
>
> Of course, we can do both
>
> f(t.[1].[1:4]...); //< dig by index, slice, expand!
>
> An empty slice will only mean copy all, it is not used for pack access (we
> use dot for that)
>
> auto t2 = t.[:]; //< We open the door an pour out everything. Same as t2
> = t1;
>
>
>
> *
> https://groups.google.com/a/isocpp.org/forum/#!searchin/std-proposals/sugar/std-proposals/n-44mMGbCv0/nMeD8_YzBwAJ
>
Actually there is more.
What if we, in the future, consider the subscript operator could take
multiple arguments? This can definitely be useful!
However with the current syntax this would be very confusing:
[0][1]t;
now becomes
[1, 0]t;
Not good.
And multiple arguments can be useful.
template<auto... I>
auto adv = t.[I...];
adv is a tuple(-like) created not from a single slice or an index, but a
mix indices *and* slices!
The I can be either an size_ or a pair<size_t, size_t> or a pair<optional<size_t>,
optional<size_t>> IFF the index is the last or first in the pack.
This way we have *complete* freedom over what we select - we can
cherry-pick some elements and consume multiple, separate groups of others.
--
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/720323ad-b208-4e8b-a90d-723a8f1d2abc%40isocpp.org.
------=_Part_26617_724266245.1514540706751
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><br><br>On Thursday, December 28, 2017 at 2:37:21 PM UTC+2=
, mihailn...@gmail.com wrote:<blockquote class=3D"gmail_quote" style=3D"mar=
gin: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><=
div dir=3D"ltr"><div>Hello, the syntax has some major problems</div><div><b=
r></div><div><span style=3D"display:inline!important;float:none;background-=
color:transparent;color:rgb(34,34,34);font-family:courier new,monospace;fon=
t-size:13px;font-style:normal;font-variant:normal;font-weight:400;letter-sp=
acing:normal;text-align:left;text-decoration:none;text-indent:0px;text-tran=
sform:none;white-space:normal;word-spacing:0px">std::tuple<int, int, int=
> t;</span></div><div><span style=3D"display:inline!important;float:none=
;background-color:transparent;color:rgb(34,34,34);font-family:courier new,m=
onospace;font-size:13px;font-style:normal;font-variant:normal;font-weight:4=
00;letter-spacing:normal;text-align:left;text-decoration:none;text-indent:0=
px;text-transform:none;white-space:normal;word-spacing:0px"><br></span></di=
v><div><font face=3D"courier new,monospace">[0][1]t;=C2=A0</font></div><div=
><font face=3D"courier new,monospace"><br></font></div><div>Should I read l=
eft to right or right to left?=C2=A0</div><div>I know the answer - right to=
left. However - we are back in the reverse invocation of get<0>(get&=
lt;1>())!</div><div><br></div><div>Even worse:</div><div><br></div><div>=
<font face=3D"courier new,monospace">[0]t[1];</font></div><div><font face=
=3D"courier new,monospace"><br></font></div><div>Is it a tuple element, whi=
ch is an array or an array element which is a tuple?!?</div><div><br></div>=
<div>Sure, there is an answer, based on operator precedence, but one must <=
i>know</i> and <i>evaluate</i> the <span style=3D"display:inline!important;=
float:none;background-color:transparent;color:rgb(34,34,34);font-family:&qu=
ot;Arial","Helvetica",sans-serif;font-size:13px;font-style:n=
ormal;font-variant:normal;font-weight:400;letter-spacing:normal;text-align:=
left;text-decoration:none;text-indent:0px;text-transform:none;white-space:n=
ormal;word-spacing:0px">precedence in his head to be able to read the code<=
/span>.</div><div>Ironically even get<> is better in that case!</div>=
<div><br></div><div><br></div><div><br></div><div>As I wrote an year ago*, =
the answer is to use the dot to enter subobjects-access, not unlike it was =
used for decades now.=C2=A0</div><div><br></div><div><br></div><div><font f=
ace=3D"courier new,monospace">t.[0].[1]; <i>//< we are digging in! The n=
atural way. Orthogonal to=C2=A0<span style=3D"text-align:left;color:rgb(34,=
34,34);text-transform:none;text-indent:0px;letter-spacing:normal;font-famil=
y:courier new,monospace;font-size:13px;font-variant:normal;font-weight:400;=
word-spacing:0px;display:inline!important;white-space:normal;float:none;bac=
kground-color:transparent">s.field.field;</span></i></font></div><div><br><=
/div><div><font face=3D"courier new,monospace"><br></font></div><div><font =
face=3D"courier new,monospace">t.[0][1]; <i>//< sure the 0 element of a =
tuple(-like) is an array</i></font></div><div><br></div><div><br></div><div=
>The moment we press the dot we signal that "we open the type". <=
/div><div><br></div><div>After we open it <i>we can index it, slice it or e=
xpand it without ambiguity=C2=A0</i></div><div><i><br></i></div><div><font =
face=3D"courier new,monospace">=C2=A0=C2=A0</font></div><div><font face=3D"=
courier new,monospace">=C2=A0 t.[0];</font></div><div><font face=3D"courier=
new,monospace">=C2=A0 t.[1:];</font></div><div><font face=3D"courier new,m=
onospace">=C2=A0 f(t...); //< note, just ..., no ambiguity. equivalent o=
f t....=C2=A0</font></div><div><font face=3D"courier new"><br></font></div>=
<div><font face=3D"courier new">=C2=A0 As for an advanced example:</font></=
div><div><font face=3D"courier new,monospace"><br></font></div><div><font f=
ace=3D"courier new,monospace" size=3D"2">=C2=A0=C2=A0=C2=A0 template<tem=
plate<class...> class... Ts> //< sizeof...(Ts) is N<br>=C2=A0=
=C2=A0=C2=A0 void f()<br>=C2=A0=C2=A0=C2=A0 {<br>=C2=A0=C2=A0=C2=A0=C2=A0=
=C2=A0 func(Ts. ...) ...; //< Param is expanded tuple, func called N tim=
es. Note, a dot to prevent ambiguity!=C2=A0</font></div><div><font face=3D"=
courier new,monospace" size=3D"2">=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0 func(Ts.) =
....; //< Expand each tuple element as a single param and call func N tim=
es. Note size must match!</font></div><div><font face=3D"courier new,monosp=
ace" size=3D"2">=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0 func(Ts) ...; //< Param i=
s the unexpanded tuple, call func N times with it</font></div><div><font fa=
ce=3D"courier new,monospace" size=3D"2">=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0 func=
(Ts...); //< Param is N unexpanded tuples, call func once<br>=C2=A0=C2=
=A0=C2=A0 }</font></div><div><font face=3D"courier new,monospace" size=3D"2=
"><br></font></div><div><br></div><div>Note the <i>subscription syntax is o=
nly needed when we need a subscript</i> - when we index or slice.</div><div=
><i><br></i></div><div>Of course, we can do both</div><div><br></div><div><=
font face=3D"courier new,monospace">f(t.[1].[1:4]...); //< dig by index,=
slice, expand!</font></div><div><font face=3D"courier new"><br></font></di=
v><div><font face=3D"arial,sans-serif">An empty slice will only mean copy a=
ll, it is not used for pack access (we use dot for that)</font></div><div><=
font face=3D"arial,sans-serif"><br></font></div><div><font face=3D"courier =
new">auto t2 =3D t.[:]; //< We open the door an pour out everything.<spa=
n style=3D"display:inline!important;float:none;background-color:transparent=
;color:rgb(34,34,34);font-family:courier new;font-size:13px;font-style:norm=
al;font-variant:normal;font-weight:400;letter-spacing:normal;text-align:lef=
t;text-decoration:none;text-indent:0px;text-transform:none;white-space:norm=
al;word-spacing:0px"> Same as t2 =3D t1;</span></font></div><div><br></div>=
<div><br></div><div><br></div><div>*<a onmousedown=3D"this.href=3D'http=
s://groups.google.com/a/isocpp.org/forum/#!searchin/std-proposals/sugar/std=
-proposals/n-44mMGbCv0/nMeD8_YzBwAJ';return true;" onclick=3D"this.href=
=3D'https://groups.google.com/a/isocpp.org/forum/#!searchin/std-proposa=
ls/sugar/std-proposals/n-44mMGbCv0/nMeD8_YzBwAJ';return true;" href=3D"=
https://groups.google.com/a/isocpp.org/forum/#!searchin/std-proposals/sugar=
/std-proposals/n-44mMGbCv0/nMeD8_YzBwAJ" target=3D"_blank" rel=3D"nofollow"=
>https://groups.google.com/a/<wbr>isocpp.org/forum/#!searchin/<wbr>std-prop=
osals/sugar/std-<wbr>proposals/n-44mMGbCv0/nMeD8_<wbr>YzBwAJ</a></div></div=
></blockquote><div><br></div><div><br></div><div>Actually there is more.</d=
iv><div><br></div><div>What if we, in the future, consider the subscript op=
erator could take multiple arguments? This can definitely be useful!</div><=
div><br></div><div>However with the current syntax this would be very confu=
sing:</div><div><br></div><div>=C2=A0<span style=3D"display: inline !import=
ant; float: none; background-color: transparent; color: rgb(34, 34, 34); fo=
nt-family: courier new,monospace; font-size: 13px; font-style: normal; font=
-variant: normal; font-weight: 400; letter-spacing: normal; orphans: 2; tex=
t-align: left; text-decoration: none; text-indent: 0px; text-transform: non=
e; -webkit-text-stroke-width: 0px; white-space: normal; word-spacing: 0px;"=
>[0][1]t;=C2=A0</span></div><div><br></div><div><span style=3D"text-align: =
left; color: rgb(34, 34, 34); text-transform: none; text-indent: 0px; lette=
r-spacing: normal; font-size: 13px; font-style: normal; font-variant: norma=
l; font-weight: 400; text-decoration: none; word-spacing: 0px; display: inl=
ine !important; white-space: normal; orphans: 2; float: none; -webkit-text-=
stroke-width: 0px; background-color: transparent;"><font face=3D"arial,sans=
-serif">now becomes=C2=A0</font></span></div><div><span style=3D"text-align=
: left; color: rgb(34, 34, 34); text-transform: none; text-indent: 0px; let=
ter-spacing: normal; font-size: 13px; font-style: normal; font-variant: nor=
mal; font-weight: 400; text-decoration: none; word-spacing: 0px; display: i=
nline !important; white-space: normal; orphans: 2; float: none; -webkit-tex=
t-stroke-width: 0px; background-color: transparent;"><br></span></div><div>=
<font face=3D"courier new,monospace">[1, 0]t;</font></div><div><font face=
=3D"courier new"><br></font></div><div><font face=3D"arial,sans-serif">Not =
good.</font></div><div><br></div><div>And multiple arguments can be useful.=
</div><div><br></div><div><font face=3D"courier new,monospace">template<=
auto... I></font></div><div><font face=3D"courier new">auto adv =3D=C2=
=A0<span style=3D"display: inline !important; float: none; background-color=
: transparent; color: rgb(34, 34, 34); font-family: courier new; font-size:=
13px; font-style: normal; font-variant: normal; font-weight: 400; letter-s=
pacing: normal; orphans: 2; text-align: left; text-decoration: none; text-i=
ndent: 0px; text-transform: none; -webkit-text-stroke-width: 0px; white-spa=
ce: normal; word-spacing: 0px;">t.[I...];</span></font></div><div><br></div=
><div><font face=3D"courier new,monospace"><br></font></div><div><span styl=
e=3D"text-align: left; color: rgb(34, 34, 34); text-transform: none; text-i=
ndent: 0px; letter-spacing: normal; font-size: 13px; font-style: normal; fo=
nt-variant: normal; font-weight: 400; text-decoration: none; word-spacing: =
0px; display: inline !important; white-space: normal; orphans: 2; float: no=
ne; -webkit-text-stroke-width: 0px; background-color: transparent;"><font f=
ace=3D"courier new,monospace">adv </font><font face=3D"arial,sans-serif">is=
a tuple(-like) created not from a single slice or an index, but a mix indi=
ces <i>and</i> slices!</font></span></div><div><span style=3D"text-align: l=
eft; color: rgb(34, 34, 34); text-transform: none; text-indent: 0px; letter=
-spacing: normal; font-size: 13px; font-style: normal; font-variant: normal=
; font-weight: 400; text-decoration: none; word-spacing: 0px; display: inli=
ne !important; white-space: normal; orphans: 2; float: none; -webkit-text-s=
troke-width: 0px; background-color: transparent;"><br></span></div><div><sp=
an style=3D"text-align: left; color: rgb(34, 34, 34); text-transform: none;=
text-indent: 0px; letter-spacing: normal; font-size: 13px; font-style: nor=
mal; font-variant: normal; font-weight: 400; text-decoration: none; word-sp=
acing: 0px; display: inline !important; white-space: normal; orphans: 2; fl=
oat: none; -webkit-text-stroke-width: 0px; background-color: transparent;">=
The <font face=3D"courier new,monospace">I </font><font face=3D"arial,sans-=
serif">can be either an size_ or a pair<size_t, size_t> or a=C2=A0<sp=
an style=3D"display: inline !important; float: none; background-color: tran=
sparent; color: rgb(34, 34, 34); font-family: arial,sans-serif; font-size: =
13px; font-style: normal; font-variant: normal; font-weight: 400; letter-sp=
acing: normal; orphans: 2; text-align: left; text-decoration: none; text-in=
dent: 0px; text-transform: none; -webkit-text-stroke-width: 0px; white-spac=
e: normal; word-spacing: 0px;">pair<optional<size_t>, optional<=
size_t>> IFF the index is the last or first in the pack.</span></font=
></span></div><div><span style=3D"text-align: left; color: rgb(34, 34, 34);=
text-transform: none; text-indent: 0px; letter-spacing: normal; font-size:=
13px; font-style: normal; font-variant: normal; font-weight: 400; text-dec=
oration: none; word-spacing: 0px; display: inline !important; white-space: =
normal; orphans: 2; float: none; -webkit-text-stroke-width: 0px; background=
-color: transparent;"><font face=3D"arial,sans-serif"><span style=3D"displa=
y: inline !important; float: none; background-color: transparent; color: rg=
b(34, 34, 34); font-family: arial,sans-serif; font-size: 13px; font-style: =
normal; font-variant: normal; font-weight: 400; letter-spacing: normal; orp=
hans: 2; text-align: left; text-decoration: none; text-indent: 0px; text-tr=
ansform: none; -webkit-text-stroke-width: 0px; white-space: normal; word-sp=
acing: 0px;"><br></span></font></span></div><div><span style=3D"text-align:=
left; color: rgb(34, 34, 34); text-transform: none; text-indent: 0px; lett=
er-spacing: normal; font-size: 13px; font-style: normal; font-variant: norm=
al; font-weight: 400; text-decoration: none; word-spacing: 0px; display: in=
line !important; white-space: normal; orphans: 2; float: none; -webkit-text=
-stroke-width: 0px; background-color: transparent;"><font face=3D"arial,san=
s-serif"><span style=3D"display: inline !important; float: none; background=
-color: transparent; color: rgb(34, 34, 34); font-family: arial,sans-serif;=
font-size: 13px; font-style: normal; font-variant: normal; font-weight: 40=
0; letter-spacing: normal; orphans: 2; text-align: left; text-decoration: n=
one; text-indent: 0px; text-transform: none; -webkit-text-stroke-width: 0px=
; white-space: normal; word-spacing: 0px;">This way we have <i>complete</i>=
freedom over what we select=C2=A0 - we can cherry-pick some elements and c=
onsume multiple, separate groups of others.</span></font></span></div><div>=
<span style=3D"text-align: left; color: rgb(34, 34, 34); text-transform: no=
ne; text-indent: 0px; letter-spacing: normal; font-size: 13px; font-style: =
normal; font-variant: normal; font-weight: 400; text-decoration: none; word=
-spacing: 0px; display: inline !important; white-space: normal; orphans: 2;=
float: none; -webkit-text-stroke-width: 0px; background-color: transparent=
;"><font face=3D"arial,sans-serif"><span style=3D"display: inline !importan=
t; float: none; background-color: transparent; color: rgb(34, 34, 34); font=
-family: arial,sans-serif; font-size: 13px; font-style: normal; font-varian=
t: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align=
: left; text-decoration: none; text-indent: 0px; text-transform: none; -web=
kit-text-stroke-width: 0px; white-space: normal; word-spacing: 0px;"><br></=
span></font></span></div><div><span style=3D"text-align: left; color: rgb(3=
4, 34, 34); text-transform: none; text-indent: 0px; letter-spacing: normal;=
font-size: 13px; font-style: normal; font-variant: normal; font-weight: 40=
0; text-decoration: none; word-spacing: 0px; display: inline !important; wh=
ite-space: normal; orphans: 2; float: none; -webkit-text-stroke-width: 0px;=
background-color: transparent;"><font face=3D"arial,sans-serif"><b><br></b=
></font></span></div><div><span style=3D"text-align: left; color: rgb(34, 3=
4, 34); text-transform: none; text-indent: 0px; letter-spacing: normal; fon=
t-size: 13px; font-style: normal; font-variant: normal; font-weight: 400; t=
ext-decoration: none; word-spacing: 0px; display: inline !important; white-=
space: normal; orphans: 2; float: none; -webkit-text-stroke-width: 0px; bac=
kground-color: transparent;">=C2=A0</span></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" 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/720323ad-b208-4e8b-a90d-723a8f1d2abc%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/720323ad-b208-4e8b-a90d-723a8f1d2abc=
%40isocpp.org</a>.<br />
------=_Part_26617_724266245.1514540706751--
------=_Part_26616_1435653405.1514540706750--
.
Author: bastienpenava@gmail.com
Date: Sun, 28 Jan 2018 11:47:46 -0800 (PST)
Raw View
------=_Part_8856_1300053461.1517168866434
Content-Type: multipart/alternative;
boundary="----=_Part_8857_221865944.1517168866435"
------=_Part_8857_221865944.1517168866435
Content-Type: text/plain; charset="UTF-8"
On Friday, December 29, 2017 at 10:45:06 AM UTC+1, mihailn...@gmail.com
wrote:
>
>
>
> On Thursday, December 28, 2017 at 2:37:21 PM UTC+2, mihailn...@gmail.com
> wrote:
>>
>> Hello, the syntax has some major problems
>>
>> std::tuple<int, int, int> t;
>>
>> [0][1]t;
>>
> It's actually simple to translate back to english: "the 0th element of the
1st element of t". Nothing difficult about it.
>
>> Should I read left to right or right to left?
>> I know the answer - right to left. However - we are back in the reverse
>> invocation of get<0>(get<1>())!
>>
>> Even worse:
>>
>> [0]t[1];
>>
> No it's actually really clear. It means [0](t[1]). A prefix operator
applies to everything afterwards, it not hard feat to understand.
The same thing applies to prefix*.
std::string *ptr;
*ptr.size(); //error did you mean '->'
(*ptr).size(); //solution
>
>> Is it a tuple element, which is an array or an array element which is a
>> tuple?!?
>>
>> Sure, there is an answer, based on operator precedence, but one must
>> *know* and *evaluate* the precedence in his head to be able to read the
>> code.
>> Ironically even get<> is better in that case!
>>
> No operator precedence knowledge is needed, just knowing that [] is a
prefix operator is enough and it's clearly visible.
>
>>
>>
>> As I wrote an year ago*, the answer is to use the dot to enter
>> subobjects-access, not unlike it was used for decades now.
>>
>>
>> t.[0].[1]; *//< we are digging in! The natural way. Orthogonal
>> to s.field.field;*
>>
>>
>> t.[0][1]; *//< sure the 0 element of a tuple(-like) is an array*
>>
>>
>> The moment we press the dot we signal that "we open the type".
>>
>> After we open it *we can index it, slice it or expand it without
>> ambiguity *
>>
>>
>> t.[0];
>> t.[1:];
>> f(t...); //< note, just ..., no ambiguity. equivalent of t....
>>
>> As for an advanced example:
>>
>> template<template<class...> class... Ts> //< sizeof...(Ts) is N
>> void f()
>> {
>> func(Ts. ...) ...; //< Param is expanded tuple, func called N
>> times. Note, a dot to prevent ambiguity!
>> func(Ts.) ...; //< Expand each tuple element as a single param and
>> call func N times. Note size must match!
>> func(Ts) ...; //< Param is the unexpanded tuple, call func N times
>> with it
>> func(Ts...); //< Param is N unexpanded tuples, call func once
>> }
>>
>>
>> Note the *subscription syntax is only needed when we need a subscript* -
>> when we index or slice.
>>
>> Of course, we can do both
>>
>> f(t.[1].[1:4]...); //< dig by index, slice, expand!
>>
>> An empty slice will only mean copy all, it is not used for pack access
>> (we use dot for that)
>>
>> auto t2 = t.[:]; //< We open the door an pour out everything. Same as t2
>> = t1;
>>
>>
>>
>> *
>> https://groups.google.com/a/isocpp.org/forum/#!searchin/std-proposals/sugar/std-proposals/n-44mMGbCv0/nMeD8_YzBwAJ
>>
>
>
> Actually there is more.
>
> What if we, in the future, consider the subscript operator could take
> multiple arguments? This can definitely be useful!
>
> However with the current syntax this would be very confusing:
>
> [0][1]t;
>
> now becomes
>
> [1, 0]t;
>
> Not good.
>
> And multiple arguments can be useful.
>
> template<auto... I>
> auto adv = t.[I...];
>
',' separated operator[] will never make consensus due to its impact on
legacy code, that's no argument.
>
>
> adv is a tuple(-like) created not from a single slice or an index, but a
> mix indices *and* slices!
>
> The I can be either an size_ or a pair<size_t, size_t> or a pair<optional<size_t>,
> optional<size_t>> IFF the index is the last or first in the pack.
>
> This way we have *complete* freedom over what we select - we can
> cherry-pick some elements and consume multiple, separate groups of others.
>
>
> Your ".[]" doesn't highlight the difference between runtime and
compile-time and would be confusing for ruby users.
Also the interesting side effect of having a prefix index operator is that
all the arguments packs contained in the expression receive the operator:
//with your version
std::forward<Args.[I]>(args.[I]);
//with the prefix version
[I]std::forward<Args>(args)
With a more complex example:
template<class... Args>
void print_reverse(Args&&...args)
{
if constexpr (sizeof...(Args) > 0)
{
auto indexs = std::make_index_sequence<sizeof...(Args) - 1>{};
std::cout << [-1]indexs;
((std::cout << [sizeof...(Args) - [:]indexs - 1]std::forward<Args>(args
)), ...);
}
std::cout << std::endl;
}
With your syntax would become:
template<class... Args>
void print_reverse(Args&&...args)
{
if constexpr (sizeof...(Args) > 0)
{
auto indexs = std::make_index_sequence<sizeof...(Args) - 1>{};
std::cout << indexs.[-1];
((std::cout << std::forward<Args.[sizeof...(Args) - indexs.[:] - 1]>(args
..[sizeof...(Args) - indexs.[:] - 1])), ...);
}
}
--
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/1b501b52-8084-43aa-b0d3-3bf75a84e4cd%40isocpp.org.
------=_Part_8857_221865944.1517168866435
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><br><br>On Friday, December 29, 2017 at 10:45:06 AM UTC+1,=
mihailn...@gmail.com wrote:<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"><br><br>On Thursday, December 28, 2017 at 2:37:21 PM UTC+2, =
<a>mihailn...@gmail.com</a> 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>Hello, the syntax has some major problems</div><div>=
<br></div><div><span style=3D"display:inline!important;float:none;backgroun=
d-color:transparent;color:rgb(34,34,34);font-family:courier new,monospace;f=
ont-size:13px;font-style:normal;font-variant:normal;font-weight:400;letter-=
spacing:normal;text-align:left;text-decoration:none;text-indent:0px;text-tr=
ansform:none;white-space:normal;word-spacing:0px">std::tuple<int, int, i=
nt> t;</span></div><div><span style=3D"display:inline!important;float:no=
ne;background-color:transparent;color:rgb(34,34,34);font-family:courier new=
,monospace;font-size:13px;font-style:normal;font-variant:normal;font-weight=
:400;letter-spacing:normal;text-align:left;text-decoration:none;text-indent=
:0px;text-transform:none;white-space:normal;word-spacing:0px"><br></span></=
div><div><font face=3D"courier new,monospace">[0][1]t;=C2=A0</font></div></=
div></blockquote></div></blockquote><div>It's actually simple to transl=
ate back to english: "the 0th element of the 1st element of t". N=
othing difficult about it.=C2=A0=C2=A0</div><blockquote class=3D"gmail_quot=
e" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;paddin=
g-left: 1ex;"><div dir=3D"ltr"><blockquote class=3D"gmail_quote" style=3D"m=
argin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-left:1ex"><div=
dir=3D"ltr"><div><font face=3D"courier new,monospace"><br></font></div><di=
v>Should I read left to right or right to left?=C2=A0</div><div>I know the =
answer - right to left. However - we are back in the reverse invocation of =
get<0>(get<1>())!</div><div><br></div><div>Even worse:</div><di=
v><br></div><div><font face=3D"courier new,monospace">[0]t[1];</font></div>=
</div></blockquote></div></blockquote><div>No it's actually really clea=
r. It means [0](t[1]). A prefix operator applies to everything afterwards, =
it not hard feat to understand.</div><div>The same thing applies to prefix*=
..</div><div>std::string *ptr;</div><div>*ptr.size(); //error did you mean &=
#39;->'</div><div>(*ptr).size(); //solution</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"><blockquote class=3D"gmail_quo=
te" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-=
left:1ex"><div dir=3D"ltr"><div><font face=3D"courier new,monospace"><br></=
font></div><div>Is it a tuple element, which is an array or an array elemen=
t which is a tuple?!?</div><div><br></div><div>Sure, there is an answer, ba=
sed on operator precedence, but one must <i>know</i> and <i>evaluate</i> th=
e <span style=3D"display:inline!important;float:none;background-color:trans=
parent;color:rgb(34,34,34);font-family:"Arial","Helvetica&qu=
ot;,sans-serif;font-size:13px;font-style:normal;font-variant:normal;font-we=
ight:400;letter-spacing:normal;text-align:left;text-decoration:none;text-in=
dent:0px;text-transform:none;white-space:normal;word-spacing:0px">precedenc=
e in his head to be able to read the code</span>.</div><div>Ironically even=
get<> is better in that case!</div></div></blockquote></div></blockq=
uote><div>No operator precedence knowledge is needed, just knowing that [] =
is a prefix operator is enough and it's clearly visible.</div><blockquo=
te class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-left:=
1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><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><br></div><div><br></div><div><br><=
/div><div>As I wrote an year ago*, the answer is to use the dot to enter su=
bobjects-access, not unlike it was used for decades now.=C2=A0</div><div><b=
r></div><div><br></div><div><font face=3D"courier new,monospace">t.[0].[1];=
<i>//< we are digging in! The natural way. Orthogonal to=C2=A0<span sty=
le=3D"text-align:left;color:rgb(34,34,34);text-transform:none;text-indent:0=
px;letter-spacing:normal;font-family:courier new,monospace;font-size:13px;f=
ont-variant:normal;font-weight:400;word-spacing:0px;display:inline!importan=
t;white-space:normal;float:none;background-color:transparent">s.field.field=
;</span></i></font></div><div><br></div><div><font face=3D"courier new,mono=
space"><br></font></div><div><font face=3D"courier new,monospace">t.[0][1];=
<i>//< sure the 0 element of a tuple(-like) is an array</i></font></div=
><div><br></div><div><br></div><div>The moment we press the dot we signal t=
hat "we open the type". </div><div><br></div><div>After we open i=
t <i>we can index it, slice it or expand it without ambiguity=C2=A0</i></di=
v><div><i><br></i></div><div><font face=3D"courier new,monospace">=C2=A0=C2=
=A0</font></div><div><font face=3D"courier new,monospace">=C2=A0 t.[0];</fo=
nt></div><div><font face=3D"courier new,monospace">=C2=A0 t.[1:];</font></d=
iv><div><font face=3D"courier new,monospace">=C2=A0 f(t...); //< note, j=
ust ..., no ambiguity. equivalent of t....=C2=A0</font></div><div><font fac=
e=3D"courier new"><br></font></div><div><font face=3D"courier new">=C2=A0 A=
s for an advanced example:</font></div><div><font face=3D"courier new,monos=
pace"><br></font></div><div><font face=3D"courier new,monospace" size=3D"2"=
>=C2=A0=C2=A0=C2=A0 template<template<class...> class... Ts> //=
< sizeof...(Ts) is N<br>=C2=A0=C2=A0=C2=A0 void f()<br>=C2=A0=C2=A0=C2=
=A0 {<br>=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0 func(Ts. ...) ...; //< Param is =
expanded tuple, func called N times. Note, a dot to prevent ambiguity!=C2=
=A0</font></div><div><font face=3D"courier new,monospace" size=3D"2">=C2=A0=
=C2=A0=C2=A0=C2=A0=C2=A0 func(Ts.) ...; //< Expand each tuple element as=
a single param and call func N times. Note size must match!</font></div><d=
iv><font face=3D"courier new,monospace" size=3D"2">=C2=A0=C2=A0=C2=A0=C2=A0=
=C2=A0 func(Ts) ...; //< Param is the unexpanded tuple, call func N time=
s with it</font></div><div><font face=3D"courier new,monospace" size=3D"2">=
=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0 func(Ts...); //< Param is N unexpanded tu=
ples, call func once<br>=C2=A0=C2=A0=C2=A0 }</font></div><div><font face=3D=
"courier new,monospace" size=3D"2"><br></font></div><div><br></div><div>Not=
e the <i>subscription syntax is only needed when we need a subscript</i> - =
when we index or slice.</div><div><i><br></i></div><div>Of course, we can d=
o both</div><div><br></div><div><font face=3D"courier new,monospace">f(t.[1=
].[1:4]...); //< dig by index, slice, expand!</font></div><div><font fac=
e=3D"courier new"><br></font></div><div><font face=3D"arial,sans-serif">An =
empty slice will only mean copy all, it is not used for pack access (we use=
dot for that)</font></div><div><font face=3D"arial,sans-serif"><br></font>=
</div><div><font face=3D"courier new">auto t2 =3D t.[:]; //< We open the=
door an pour out everything.<span style=3D"display:inline!important;float:=
none;background-color:transparent;color:rgb(34,34,34);font-family:courier n=
ew;font-size:13px;font-style:normal;font-variant:normal;font-weight:400;let=
ter-spacing:normal;text-align:left;text-decoration:none;text-indent:0px;tex=
t-transform:none;white-space:normal;word-spacing:0px"> Same as t2 =3D t1;</=
span></font></div><div><br></div><div><br></div><div><br></div><div>*<a hre=
f=3D"https://groups.google.com/a/isocpp.org/forum/#!searchin/std-proposals/=
sugar/std-proposals/n-44mMGbCv0/nMeD8_YzBwAJ" rel=3D"nofollow" target=3D"_b=
lank" onmousedown=3D"this.href=3D'https://groups.google.com/a/isocpp.or=
g/forum/#!searchin/std-proposals/sugar/std-proposals/n-44mMGbCv0/nMeD8_YzBw=
AJ';return true;" onclick=3D"this.href=3D'https://groups.google.com=
/a/isocpp.org/forum/#!searchin/std-proposals/sugar/std-proposals/n-44mMGbCv=
0/nMeD8_YzBwAJ';return true;">https://groups.google.com/a/<wbr>isocpp.o=
rg/forum/#!searchin/<wbr>std-proposals/sugar/std-<wbr>proposals/n-44mMGbCv0=
/nMeD8_<wbr>YzBwAJ</a></div></div></blockquote><div><br></div><div><br></di=
v><div>Actually there is more.</div><div><br></div><div>What if we, in the =
future, consider the subscript operator could take multiple arguments? This=
can definitely be useful!</div><div><br></div><div>However with the curren=
t syntax this would be very confusing:</div><div><br></div><div>=C2=A0<span=
style=3D"display:inline!important;float:none;background-color:transparent;=
color:rgb(34,34,34);font-family:courier new,monospace;font-size:13px;font-s=
tyle:normal;font-variant:normal;font-weight:400;letter-spacing:normal;text-=
align:left;text-decoration:none;text-indent:0px;text-transform:none;white-s=
pace:normal;word-spacing:0px">[0][1]t;=C2=A0</span></div></div></blockquote=
><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></d=
iv><div><span style=3D"text-align:left;color:rgb(34,34,34);text-transform:n=
one;text-indent:0px;letter-spacing:normal;font-size:13px;font-style:normal;=
font-variant:normal;font-weight:400;text-decoration:none;word-spacing:0px;d=
isplay:inline!important;white-space:normal;float:none;background-color:tran=
sparent"><font face=3D"arial,sans-serif">now becomes=C2=A0</font></span></d=
iv><div><span style=3D"text-align:left;color:rgb(34,34,34);text-transform:n=
one;text-indent:0px;letter-spacing:normal;font-size:13px;font-style:normal;=
font-variant:normal;font-weight:400;text-decoration:none;word-spacing:0px;d=
isplay:inline!important;white-space:normal;float:none;background-color:tran=
sparent"><br></span></div><div><font face=3D"courier new,monospace">[1, 0]t=
;</font></div><div><font face=3D"courier new"><br></font></div><div><font f=
ace=3D"arial,sans-serif">Not good.</font></div><div><br></div><div>And mult=
iple arguments can be useful.</div><div><br></div><div><font face=3D"courie=
r new,monospace">template<auto... I></font></div><div><font face=3D"c=
ourier new">auto adv =3D=C2=A0<span style=3D"display:inline!important;float=
:none;background-color:transparent;color:rgb(34,34,34);font-family:courier =
new;font-size:13px;font-style:normal;font-variant:normal;font-weight:400;le=
tter-spacing:normal;text-align:left;text-decoration:none;text-indent:0px;te=
xt-transform:none;white-space:normal;word-spacing:0px">t.[I...];</span></fo=
nt></div></div></blockquote><div>',' separated operator[] will neve=
r make consensus due to its impact on legacy code, that's no argument.<=
/div><blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8e=
x;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><div><br=
></div><div><font face=3D"courier new,monospace"><br></font></div><div><spa=
n style=3D"text-align:left;color:rgb(34,34,34);text-transform:none;text-ind=
ent:0px;letter-spacing:normal;font-size:13px;font-style:normal;font-variant=
:normal;font-weight:400;text-decoration:none;word-spacing:0px;display:inlin=
e!important;white-space:normal;float:none;background-color:transparent"><fo=
nt face=3D"courier new,monospace">adv </font><font face=3D"arial,sans-serif=
">is a tuple(-like) created not from a single slice or an index, but a mix =
indices <i>and</i> slices!</font></span></div><div><span style=3D"text-alig=
n:left;color:rgb(34,34,34);text-transform:none;text-indent:0px;letter-spaci=
ng:normal;font-size:13px;font-style:normal;font-variant:normal;font-weight:=
400;text-decoration:none;word-spacing:0px;display:inline!important;white-sp=
ace:normal;float:none;background-color:transparent"><br></span></div><div><=
span style=3D"text-align:left;color:rgb(34,34,34);text-transform:none;text-=
indent:0px;letter-spacing:normal;font-size:13px;font-style:normal;font-vari=
ant:normal;font-weight:400;text-decoration:none;word-spacing:0px;display:in=
line!important;white-space:normal;float:none;background-color:transparent">=
The <font face=3D"courier new,monospace">I </font><font face=3D"arial,sans-=
serif">can be either an size_ or a pair<size_t, size_t> or a=C2=A0<sp=
an style=3D"display:inline!important;float:none;background-color:transparen=
t;color:rgb(34,34,34);font-family:arial,sans-serif;font-size:13px;font-styl=
e:normal;font-variant:normal;font-weight:400;letter-spacing:normal;text-ali=
gn:left;text-decoration:none;text-indent:0px;text-transform:none;white-spac=
e:normal;word-spacing:0px">pair<optional<size_t>, optional<size=
_t>> IFF the index is the last or first in the pack.</span></font></s=
pan></div><div><span style=3D"text-align:left;color:rgb(34,34,34);text-tran=
sform:none;text-indent:0px;letter-spacing:normal;font-size:13px;font-style:=
normal;font-variant:normal;font-weight:400;text-decoration:none;word-spacin=
g:0px;display:inline!important;white-space:normal;float:none;background-col=
or:transparent"><font face=3D"arial,sans-serif"><span style=3D"display:inli=
ne!important;float:none;background-color:transparent;color:rgb(34,34,34);fo=
nt-family:arial,sans-serif;font-size:13px;font-style:normal;font-variant:no=
rmal;font-weight:400;letter-spacing:normal;text-align:left;text-decoration:=
none;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0p=
x"><br></span></font></span></div><div><span style=3D"text-align:left;color=
:rgb(34,34,34);text-transform:none;text-indent:0px;letter-spacing:normal;fo=
nt-size:13px;font-style:normal;font-variant:normal;font-weight:400;text-dec=
oration:none;word-spacing:0px;display:inline!important;white-space:normal;f=
loat:none;background-color:transparent"><font face=3D"arial,sans-serif"><sp=
an style=3D"display:inline!important;float:none;background-color:transparen=
t;color:rgb(34,34,34);font-family:arial,sans-serif;font-size:13px;font-styl=
e:normal;font-variant:normal;font-weight:400;letter-spacing:normal;text-ali=
gn:left;text-decoration:none;text-indent:0px;text-transform:none;white-spac=
e:normal;word-spacing:0px">This way we have <i>complete</i> freedom over wh=
at we select=C2=A0 - we can cherry-pick some elements and consume multiple,=
separate groups of others.</span></font></span></div><div><span style=3D"t=
ext-align:left;color:rgb(34,34,34);text-transform:none;text-indent:0px;lett=
er-spacing:normal;font-size:13px;font-style:normal;font-variant:normal;font=
-weight:400;text-decoration:none;word-spacing:0px;display:inline!important;=
white-space:normal;float:none;background-color:transparent"><font face=3D"a=
rial,sans-serif"><span style=3D"display:inline!important;float:none;backgro=
und-color:transparent;color:rgb(34,34,34);font-family:arial,sans-serif;font=
-size:13px;font-style:normal;font-variant:normal;font-weight:400;letter-spa=
cing:normal;text-align:left;text-decoration:none;text-indent:0px;text-trans=
form:none;white-space:normal;word-spacing:0px"><br></span></font></span></d=
iv><div><span style=3D"text-align:left;color:rgb(34,34,34);text-transform:n=
one;text-indent:0px;letter-spacing:normal;font-size:13px;font-style:normal;=
font-variant:normal;font-weight:400;text-decoration:none;word-spacing:0px;d=
isplay:inline!important;white-space:normal;float:none;background-color:tran=
sparent"><font face=3D"arial,sans-serif"><b><br></b></font></span></div></d=
iv></blockquote><div><span style=3D"background-color: transparent;">Your &q=
uot;.[]" doesn't highlight the difference between runtime and comp=
ile-time and would be confusing for ruby users.</span></div><div><span styl=
e=3D"background-color: transparent;">Also the interesting=C2=A0side effect =
of having a prefix index operator is that all the arguments packs contained=
in the expression receive the operator:</span></div><div class=3D"prettypr=
int" style=3D"background-color: rgb(250, 250, 250); border-color: rgb(187, =
187, 187); border-style: solid; border-width: 1px; word-wrap: break-word;">=
<code class=3D"prettyprint"><div class=3D"subprettyprint"><span style=3D"co=
lor: #800;" class=3D"styled-by-prettify">//with your version</span><span st=
yle=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"colo=
r: #000;" class=3D"styled-by-prettify">forward</span><span style=3D"color: =
#660;" class=3D"styled-by-prettify"><</span><span style=3D"color: #606;"=
class=3D"styled-by-prettify">Args</span><span style=3D"color: #660;" class=
=3D"styled-by-prettify">.[</span><span style=3D"color: #000;" class=3D"styl=
ed-by-prettify">I</span><span style=3D"color: #660;" class=3D"styled-by-pre=
ttify">]>(</span><span style=3D"color: #000;" class=3D"styled-by-prettif=
y">args</span><span style=3D"color: #660;" class=3D"styled-by-prettify">.[<=
/span><span style=3D"color: #000;" class=3D"styled-by-prettify">I</span><sp=
an style=3D"color: #660;" class=3D"styled-by-prettify">]);</span><span styl=
e=3D"color: #000;" class=3D"styled-by-prettify"><br></span><span style=3D"c=
olor: #800;" class=3D"styled-by-prettify">//with the prefix version</span><=
span style=3D"color: #000;" class=3D"styled-by-prettify"><br></span><span s=
tyle=3D"color: #660;" class=3D"styled-by-prettify">[</span><span style=3D"c=
olor: #000;" class=3D"styled-by-prettify">I</span><span style=3D"color: #66=
0;" class=3D"styled-by-prettify">]</span><span style=3D"color: #000;" class=
=3D"styled-by-prettify">std</span><span style=3D"color: #660;" class=3D"sty=
led-by-prettify">::</span><span style=3D"color: #000;" class=3D"styled-by-p=
rettify">forward</span><span style=3D"color: #660;" class=3D"styled-by-pret=
tify"><</span><span style=3D"color: #606;" class=3D"styled-by-prettify">=
Args</span><span style=3D"color: #660;" class=3D"styled-by-prettify">>(<=
/span><span style=3D"color: #000;" class=3D"styled-by-prettify">args</span>=
<span style=3D"color: #660;" class=3D"styled-by-prettify">)</span></div></c=
ode></div><div><br></div><div>With a more complex example:</div><div class=
=3D"prettyprint" style=3D"background-color: rgb(250, 250, 250); border-colo=
r: rgb(187, 187, 187); border-style: solid; border-width: 1px; word-wrap: b=
reak-word;"><code class=3D"prettyprint"><div class=3D"subprettyprint"><span=
style=3D"color: #008;" class=3D"styled-by-prettify">template</span><span s=
tyle=3D"color: #660;" class=3D"styled-by-prettify"><</span><span style=
=3D"color: #008;" class=3D"styled-by-prettify">class</span><span style=3D"c=
olor: #660;" class=3D"styled-by-prettify">...</span><span style=3D"color: #=
000;" class=3D"styled-by-prettify"> </span><span style=3D"color: #606;" cla=
ss=3D"styled-by-prettify">Args</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: #008;" class=3D"styled-by-pr=
ettify">void</span><span style=3D"color: #000;" class=3D"styled-by-prettify=
"> print_reverse</span><span style=3D"color: #660;" class=3D"styled-by-pret=
tify">(</span><span style=3D"color: #606;" class=3D"styled-by-prettify">Arg=
s</span><span style=3D"color: #660;" class=3D"styled-by-prettify">&&=
;...</span><span style=3D"color: #000;" class=3D"styled-by-prettify">args</=
span><span style=3D"color: #660;" class=3D"styled-by-prettify">)</span><spa=
n style=3D"color: #000;" class=3D"styled-by-prettify"><br></span><span styl=
e=3D"color: #660;" class=3D"styled-by-prettify">{</span><span style=3D"colo=
r: #000;" class=3D"styled-by-prettify"><br>=C2=A0</span><span style=3D"colo=
r: #008;" class=3D"styled-by-prettify">if</span><span style=3D"color: #000;=
" class=3D"styled-by-prettify"> </span><span style=3D"color: #008;" class=
=3D"styled-by-prettify">constexpr</span><span style=3D"color: #000;" class=
=3D"styled-by-prettify"> </span><span style=3D"color: #660;" class=3D"style=
d-by-prettify">(</span><span style=3D"color: #008;" class=3D"styled-by-pret=
tify">sizeof</span><span style=3D"color: #660;" class=3D"styled-by-prettify=
">...(</span><span style=3D"color: #606;" class=3D"styled-by-prettify">Args=
</span><span style=3D"color: #660;" class=3D"styled-by-prettify">)</span><s=
pan style=3D"color: #000;" class=3D"styled-by-prettify"> </span><span style=
=3D"color: #660;" class=3D"styled-by-prettify">></span><span style=3D"co=
lor: #000;" class=3D"styled-by-prettify"> </span><span style=3D"color: #066=
;" class=3D"styled-by-prettify">0</span><span style=3D"color: #660;" class=
=3D"styled-by-prettify">)</span><span style=3D"color: #000;" class=3D"style=
d-by-prettify"><br>=C2=A0</span><span style=3D"color: #660;" class=3D"style=
d-by-prettify">{</span><span style=3D"color: #000;" class=3D"styled-by-pret=
tify"><br>=C2=A0 =C2=A0</span><span style=3D"color: #008;" class=3D"styled-=
by-prettify">auto</span><span style=3D"color: #000;" class=3D"styled-by-pre=
ttify"> indexs </span><span style=3D"color: #660;" class=3D"styled-by-prett=
ify">=3D</span><span style=3D"color: #000;" class=3D"styled-by-prettify"> s=
td</span><span style=3D"color: #660;" class=3D"styled-by-prettify">::</span=
><span style=3D"color: #000;" class=3D"styled-by-prettify">make_index_seque=
nce</span><span style=3D"color: #660;" class=3D"styled-by-prettify"><</s=
pan><span style=3D"color: #008;" class=3D"styled-by-prettify">sizeof</span>=
<span style=3D"color: #660;" class=3D"styled-by-prettify">...(</span><span =
style=3D"color: #606;" class=3D"styled-by-prettify">Args</span><span style=
=3D"color: #660;" class=3D"styled-by-prettify">)</span><span style=3D"color=
: #000;" class=3D"styled-by-prettify"> </span><span style=3D"color: #660;" =
class=3D"styled-by-prettify">-</span><span style=3D"color: #000;" class=3D"=
styled-by-prettify"> </span><span style=3D"color: #066;" class=3D"styled-by=
-prettify">1</span><span style=3D"color: #660;" class=3D"styled-by-prettify=
">>{};</span><span style=3D"color: #000;" class=3D"styled-by-prettify"><=
br>=C2=A0 =C2=A0std</span><span style=3D"color: #660;" class=3D"styled-by-p=
rettify">::</span><span style=3D"color: #000;" class=3D"styled-by-prettify"=
>cout </span><span style=3D"color: #660;" class=3D"styled-by-prettify"><=
<</span><span style=3D"color: #000;" class=3D"styled-by-prettify"> </spa=
n><span style=3D"color: #660;" class=3D"styled-by-prettify">[-</span><span =
style=3D"color: #066;" class=3D"styled-by-prettify">1</span><span style=3D"=
color: #660;" class=3D"styled-by-prettify">]</span><span style=3D"color: #0=
00;" class=3D"styled-by-prettify">indexs</span><span style=3D"color: #660;"=
class=3D"styled-by-prettify">;</span><span style=3D"color: #000;" class=3D=
"styled-by-prettify"><br>=C2=A0 =C2=A0</span><span style=3D"color: #660;" c=
lass=3D"styled-by-prettify">((</span><span style=3D"color: #000;" class=3D"=
styled-by-prettify">std</span><span style=3D"color: #660;" class=3D"styled-=
by-prettify">::</span><span style=3D"color: #000;" class=3D"styled-by-prett=
ify">cout </span><span style=3D"color: #660;" class=3D"styled-by-prettify">=
<<</span><span style=3D"color: #000;" class=3D"styled-by-prettify"> <=
/span><span style=3D"color: #660;" class=3D"styled-by-prettify">[</span><sp=
an style=3D"color: #008;" class=3D"styled-by-prettify">sizeof</span><span s=
tyle=3D"color: #660;" class=3D"styled-by-prettify">...(</span><span style=
=3D"color: #606;" class=3D"styled-by-prettify">Args</span><span style=3D"co=
lor: #660;" class=3D"styled-by-prettify">)</span><span style=3D"color: #000=
;" class=3D"styled-by-prettify"> </span><span style=3D"color: #660;" class=
=3D"styled-by-prettify">-</span><span style=3D"color: #000;" class=3D"style=
d-by-prettify"> </span><span style=3D"color: #660;" class=3D"styled-by-pret=
tify">[:]</span><span style=3D"color: #000;" class=3D"styled-by-prettify">i=
ndexs </span><span style=3D"color: #660;" class=3D"styled-by-prettify">-</s=
pan><span style=3D"color: #000;" class=3D"styled-by-prettify"> </span><span=
style=3D"color: #066;" class=3D"styled-by-prettify">1</span><span style=3D=
"color: #660;" class=3D"styled-by-prettify">]</span><span style=3D"color: #=
000;" class=3D"styled-by-prettify">std</span><span style=3D"color: #660;" c=
lass=3D"styled-by-prettify">::</span><span style=3D"color: #000;" class=3D"=
styled-by-prettify">forward</span><span style=3D"color: #660;" class=3D"sty=
led-by-prettify"><</span><span style=3D"color: #606;" class=3D"styled-by=
-prettify">Args</span><span style=3D"color: #660;" class=3D"styled-by-prett=
ify">>(</span><span style=3D"color: #000;" class=3D"styled-by-prettify">=
args</span><span style=3D"color: #660;" class=3D"styled-by-prettify">)),</s=
pan><span style=3D"color: #000;" class=3D"styled-by-prettify"> </span><span=
style=3D"color: #660;" class=3D"styled-by-prettify">...);</span><span styl=
e=3D"color: #000;" class=3D"styled-by-prettify"><br>=C2=A0</span><span styl=
e=3D"color: #660;" class=3D"styled-by-prettify">}</span><span style=3D"colo=
r: #000;" class=3D"styled-by-prettify"><br>=C2=A0std</span><span style=3D"c=
olor: #660;" class=3D"styled-by-prettify">::</span><span style=3D"color: #0=
00;" class=3D"styled-by-prettify">cout </span><span style=3D"color: #660;" =
class=3D"styled-by-prettify"><<</span><span style=3D"color: #000;" cl=
ass=3D"styled-by-prettify"> std</span><span style=3D"color: #660;" class=3D=
"styled-by-prettify">::</span><span style=3D"color: #000;" class=3D"styled-=
by-prettify">endl</span><span style=3D"color: #660;" class=3D"styled-by-pre=
ttify">;</span><span style=3D"color: #000;" class=3D"styled-by-prettify"><b=
r></span><span style=3D"color: #660;" 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>With your syntax would become:</div><div c=
lass=3D"prettyprint" style=3D"background-color: rgb(250, 250, 250); border-=
color: rgb(187, 187, 187); border-style: solid; border-width: 1px; word-wra=
p: break-word;"><code class=3D"prettyprint"><div class=3D"subprettyprint"><=
span style=3D"color: #008;" class=3D"styled-by-prettify">template</span><sp=
an style=3D"color: #660;" class=3D"styled-by-prettify"><</span><span sty=
le=3D"color: #008;" class=3D"styled-by-prettify">class</span><span style=3D=
"color: #660;" class=3D"styled-by-prettify">...</span><span style=3D"color:=
#000;" class=3D"styled-by-prettify"> </span><span style=3D"color: #606;" c=
lass=3D"styled-by-prettify">Args</span><span style=3D"color: #660;" class=
=3D"styled-by-prettify">></span><span style=3D"color: #000;" class=3D"st=
yled-by-prettify"><br></span><span style=3D"color: #008;" class=3D"styled-b=
y-prettify">void</span><span style=3D"color: #000;" class=3D"styled-by-pret=
tify"> print_reverse</span><span style=3D"color: #660;" class=3D"styled-by-=
prettify">(</span><span style=3D"color: #606;" class=3D"styled-by-prettify"=
>Args</span><span style=3D"color: #660;" class=3D"styled-by-prettify">&=
&...</span><span style=3D"color: #000;" class=3D"styled-by-prettify">ar=
gs</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"styled-by-prettify">{</span><span style=3D"=
color: #000;" class=3D"styled-by-prettify"><br>=C2=A0</span><span style=3D"=
color: #008;" class=3D"styled-by-prettify">if</span><span style=3D"color: #=
000;" class=3D"styled-by-prettify"> </span><span style=3D"color: #008;" cla=
ss=3D"styled-by-prettify">constexpr</span><span style=3D"color: #000;" clas=
s=3D"styled-by-prettify"> </span><span style=3D"color: #660;" class=3D"styl=
ed-by-prettify">(</span><span style=3D"color: #008;" class=3D"styled-by-pre=
ttify">sizeof</span><span style=3D"color: #660;" class=3D"styled-by-prettif=
y">...(</span><span style=3D"color: #606;" class=3D"styled-by-prettify">Arg=
s</span><span style=3D"color: #660;" class=3D"styled-by-prettify">)</span><=
span style=3D"color: #000;" class=3D"styled-by-prettify"> </span><span styl=
e=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: #06=
6;" class=3D"styled-by-prettify">0</span><span style=3D"color: #660;" class=
=3D"styled-by-prettify">)</span><span style=3D"color: #000;" class=3D"style=
d-by-prettify"><br>=C2=A0</span><span style=3D"color: #660;" class=3D"style=
d-by-prettify">{</span><span style=3D"color: #000;" class=3D"styled-by-pret=
tify"><br>=C2=A0 =C2=A0</span><span style=3D"color: #008;" class=3D"styled-=
by-prettify">auto</span><span style=3D"color: #000;" class=3D"styled-by-pre=
ttify"> indexs </span><span style=3D"color: #660;" class=3D"styled-by-prett=
ify">=3D</span><span style=3D"color: #000;" class=3D"styled-by-prettify"> s=
td</span><span style=3D"color: #660;" class=3D"styled-by-prettify">::</span=
><span style=3D"color: #000;" class=3D"styled-by-prettify">make_index_seque=
nce</span><span style=3D"color: #660;" class=3D"styled-by-prettify"><</s=
pan><span style=3D"color: #008;" class=3D"styled-by-prettify">sizeof</span>=
<span style=3D"color: #660;" class=3D"styled-by-prettify">...(</span><span =
style=3D"color: #606;" class=3D"styled-by-prettify">Args</span><span style=
=3D"color: #660;" class=3D"styled-by-prettify">)</span><span style=3D"color=
: #000;" class=3D"styled-by-prettify"> </span><span style=3D"color: #660;" =
class=3D"styled-by-prettify">-</span><span style=3D"color: #000;" class=3D"=
styled-by-prettify"> </span><span style=3D"color: #066;" class=3D"styled-by=
-prettify">1</span><span style=3D"color: #660;" class=3D"styled-by-prettify=
">>{};</span><span style=3D"color: #000;" class=3D"styled-by-prettify"><=
br>=C2=A0 =C2=A0std</span><span style=3D"color: #660;" class=3D"styled-by-p=
rettify">::</span><span style=3D"color: #000;" class=3D"styled-by-prettify"=
>cout </span><span style=3D"color: #660;" class=3D"styled-by-prettify"><=
<</span><span style=3D"color: #000;" class=3D"styled-by-prettify"> index=
s</span><span style=3D"color: #660;" class=3D"styled-by-prettify">.[-</span=
><span style=3D"color: #066;" class=3D"styled-by-prettify">1</span><span st=
yle=3D"color: #660;" class=3D"styled-by-prettify">];</span><span style=3D"c=
olor: #000;" class=3D"styled-by-prettify"><br>=C2=A0 =C2=A0</span><span sty=
le=3D"color: #660;" class=3D"styled-by-prettify">((</span><span style=3D"co=
lor: #000;" class=3D"styled-by-prettify">std</span><span style=3D"color: #6=
60;" class=3D"styled-by-prettify">::</span><span style=3D"color: #000;" cla=
ss=3D"styled-by-prettify">cout </span><span style=3D"color: #660;" class=3D=
"styled-by-prettify"><<</span><span style=3D"color: #000;" class=3D"s=
tyled-by-prettify"> std</span><span style=3D"color: #660;" class=3D"styled-=
by-prettify">::</span><span style=3D"color: #000;" class=3D"styled-by-prett=
ify">forward</span><span style=3D"color: #660;" class=3D"styled-by-prettify=
"><</span><span style=3D"color: #606;" class=3D"styled-by-prettify">Args=
</span><span style=3D"color: #660;" class=3D"styled-by-prettify">.[</span><=
span style=3D"color: #008;" class=3D"styled-by-prettify">sizeof</span><span=
style=3D"color: #660;" class=3D"styled-by-prettify">...(</span><span style=
=3D"color: #606;" class=3D"styled-by-prettify">Args</span><span style=3D"co=
lor: #660;" class=3D"styled-by-prettify">)</span><span style=3D"color: #000=
;" class=3D"styled-by-prettify"> </span><span style=3D"color: #660;" class=
=3D"styled-by-prettify">-</span><span style=3D"color: #000;" class=3D"style=
d-by-prettify"> indexs</span><span style=3D"color: #660;" class=3D"styled-b=
y-prettify">.[:]</span><span style=3D"color: #000;" class=3D"styled-by-pret=
tify"> </span><span style=3D"color: #660;" class=3D"styled-by-prettify">-</=
span><span style=3D"color: #000;" class=3D"styled-by-prettify"> </span><spa=
n style=3D"color: #066;" class=3D"styled-by-prettify">1</span><span style=
=3D"color: #660;" class=3D"styled-by-prettify">]>(</span><span style=3D"=
color: #000;" class=3D"styled-by-prettify">args</span><span style=3D"color:=
#660;" class=3D"styled-by-prettify">.[</span><span style=3D"color: #008;" =
class=3D"styled-by-prettify">sizeof</span><span style=3D"color: #660;" clas=
s=3D"styled-by-prettify">...(</span><span style=3D"color: #606;" class=3D"s=
tyled-by-prettify">Args</span><span style=3D"color: #660;" class=3D"styled-=
by-prettify">)</span><span style=3D"color: #000;" class=3D"styled-by-pretti=
fy"> </span><span style=3D"color: #660;" class=3D"styled-by-prettify">-</sp=
an><span style=3D"color: #000;" class=3D"styled-by-prettify"> indexs</span>=
<span style=3D"color: #660;" class=3D"styled-by-prettify">.[:]</span><span =
style=3D"color: #000;" class=3D"styled-by-prettify"> </span><span style=3D"=
color: #660;" class=3D"styled-by-prettify">-</span><span style=3D"color: #0=
00;" class=3D"styled-by-prettify"> </span><span style=3D"color: #066;" clas=
s=3D"styled-by-prettify">1</span><span style=3D"color: #660;" class=3D"styl=
ed-by-prettify">])),</span><span style=3D"color: #000;" class=3D"styled-by-=
prettify"> </span><span style=3D"color: #660;" class=3D"styled-by-prettify"=
>...);</span><span style=3D"color: #000;" class=3D"styled-by-prettify"><br>=
=C2=A0</span><span style=3D"color: #660;" class=3D"styled-by-prettify">}</s=
pan><span style=3D"color: #000;" class=3D"styled-by-prettify"><br></span><s=
pan style=3D"color: #660;" class=3D"styled-by-prettify">}</span></div></cod=
e></div><br><br></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" 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/1b501b52-8084-43aa-b0d3-3bf75a84e4cd%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/1b501b52-8084-43aa-b0d3-3bf75a84e4cd=
%40isocpp.org</a>.<br />
------=_Part_8857_221865944.1517168866435--
------=_Part_8856_1300053461.1517168866434--
.