std::tuple<A, B, C> tup = ...;
std::apply([&](auto&&... elems){
    // now I have a pack
}, tup);

std::tuple<X, Y, Z> f();

auto [x,y,z] = f();          // OK today
auto [...xs] = f();          // proposed: xs is a pack of length three containing an X, Y, and a Z
auto [x, ...rest] = f();     // proposed: x is an X, rest is a pack of length two (Y and Z)
auto [x,y,z, ...rest] = f(); // proposed: rest is an empty pack
auto [x, ...rest, z] = f();  // proposed: x is an X, rest is a pack of length one
                             //   consisting of the Y, z is a Z
auto [...a, ...b] = f();     // ill-formed: multiple packs

struct Point {
    int x, y, z;
};

Point getPoint();
double calc(int, int, int);

double result = std::apply(calc, getPoint()); // ill-formed today, ok with proposed implementation

>>> a, b, c, d, e = range(5) # ok
>>> a, *b = range(3)
  File "<stdin>", line 1
    a, *b = range(3)
       ^
SyntaxError: invalid syntax

>>> a, *b, c = range(5)
>>> a
0
>>> c
4
>>> b
[1, 2, 3]

template <typeanme Tuple>
auto sum_template(Tuple tuple) {
    auto [...elems] = tuple;
    return (... + elems);
}

auto sum_non_template(SomeConreteType tuple) {
    auto [...elems] = tuple;
    return (... + elems);
}

std::meta::info t_args[] = { ^int, ^42 };
template<typename T, T> struct X {};
X<...[:t_args:]...> x; // Same as "X<int, 42> x;".
template<typename, typename> struct Y {};
Y<...[:t_args:]...> y; // Error: same as "Y<int, 42> y;".

- attributed-identifier:
-     identifier attribute-specifier-seqopt
+ sb-identifier:
+     ...opt identifier attribute-specifier-seqopt
+
- attributed-identifier-list:
-     attributed-identifier
-     attributed-identifier-list, attributed-identifier
+ sb-identifier-list:
+     sb-identifier
+     sb-identifier-list, sb-identifier

  structured-binding-declaration:
-    attribute-specifier-seqopt decl-specifier-seq ref-qualifieropt [ attributed-identifier-list ]
+    attribute-specifier-seqopt decl-specifier-seq ref-qualifieropt [ sb-identifier-list ]

6 A simple-declaration with a structured-binding-declaration is called a structured binding declaration ([dcl.struct.bind]). Each decl-specifier in the decl-specifier-seq shall be static, thread_local, auto ([dcl.spec.auto]), or a cv-qualifier. The declaration shall contain at most one sb-identifier whose identifier is preceded by an ellipsis. If the declaration contains any such sb-identifier, it shall declare a templated entity ([temp.pre]).

1 A structured binding declaration introduces the identifiers v₀, v₁, v₂, …, v_N-1 of the attribute-identifier-list-list sb-identifier-list as names ([basic.scope.declarative]) of structured bindings. An sb-identifier that contains an ellipsis introduces a structured binding pack ([temp.variadic]). A structured binding is either an sb-identifier that does not contain an ellipsis or an element of a structured binding pack. The optional attribute-specifier-seq of an attributed-identifier sb-identifier appertains to the associated structured bindings so introduced. Let cv denote the cv-qualifiers in the decl-specifier-seq.

3 If E is an array type with element type T, the number of elements in the attributed-identifier-list shall be the structured binding size of E is equal to the number of elements of E. Each v_i SB_i is the name of an lvalue that refers to the element i of the array and whose type is T; the referenced type is T. [Note: The top-level cv-qualifiers of T are cv. — end note]

[ Example 2:

  auto f() -> int(&)[2];
  auto [ x, y ] = f();            // x and y refer to elements in a copy of the array return value
  auto& [ xr, yr ] = f();         // xr and yr refer to elements in the array referred to by f's return value

+ auto g() -> int(&)[4];

+ template <size_t N>
+ void h(int (&arr)[N]) {
+   auto [a, ...b, c] = arr;   // a names the first element of the array, b is a pack referring to the second and
+                              // third elements, and c names the fourth element
+   auto& [...e] = arr;        // e is a pack referring to the four elements of the array
+ }
+
+ void call_h() {
+   h(g());
+ }

— end example ]

4 Otherwise, if the qualified-id std::tuple_size<E> names a complete type, the expression std::tuple_size<E>::value shall be a well-formed integral constant expression and the number of elements in the attributed-identifier-list shall be structured binding size of E is equal to the value of that expression. […] Each v_i SB_i is the name of an lvalue of type Ti that refers to the object bound to ri; the referenced type is Ti.

5 Otherwise, all of E’s non-static data members shall be direct members of E or of the same base class of E, well-formed when named as e.name in the context of the structured binding, E shall not have an anonymous union member, and the number of elements in the attributed-identifier-list shall be structured binding size of E is equal to the number of non-static data members of E. Designating the non-static data members of E as m0, m1, m2, . . . (in declaration order), each vi SB_i is the name of an lvalue that refers to the member mi of E and whose type is cv Ti, where Ti is the declared type of that member; the referenced type is cv Ti. The lvalue is a bit-field if that member is a bit-field.

4 A pack is a template parameter pack, a function parameter pack, or an init-capture pack, or a structured binding pack. The number of elements of a template parameter pack or a function parameter pack is the number of arguments provided for the parameter pack. The number of elements of an init-capture pack is the number of elements in the pack expansion of its initializer.

8 Such an element, in the context of the instantiation, is interpreted as follows:

• (8.1) if the pack is a template parameter pack, the element is a template parameter ([temp.param]) of the corresponding kind (type or non-type) designating the i^th corresponding type or value template argument;
• (8.2) if the pack is a function parameter pack, the element is an id-expression designating the i^th function parameter that resulted from instantiation of the function parameter pack declaration; otherwise
• (8.3) if the pack is an init-capture pack, the element is an id-expression designating the variable introduced by the i^thth init-capture that resulted from instantiation of the init-capture pack. ; otherwise
• (8.4) if the pack is a structured binding pack, the element is an id-expression designating the i^th structured binding in the pack that resulted from the structured binding declaration.

3 An id-expression is type-dependent if it is a template-id that is not a concept-id and is dependent; or if its terminal name is

• (3.1) associated by name lookup with one or more declarations declared with a dependent type,

• (3.2) associated by name lookup with a non-type template-parameter declared with a type that contains a placeholder type,

• (3.3) associated by name lookup with a variable declared with a type that contains a placeholder type ([dcl.spec.auto]) where the initializer is type-dependent,

• (3.4) associated by name lookup with one or more declarations of member functions of a class that is the current instantiation declared with a return type that contains a placeholder type,

• (3.5) associated by name lookup with a structured binding declaration ([dcl.struct.bind]) whose brace-or-equal-initializer is type-dependent,

• (3.5b) associated by name lookup with a pack,

  [ Example 4:

  struct C { };
  
  void g(...); // #1
  
  template <typename T>
  void f() {
      C arr[1];
      auto [...e] = arr;
      g(e...); // calls #2
  }
  
  void g(C); // #2
  
  int main() {
      f<int>();
  }

  — end example ]

• (3.6) associated by name lookup with an entity captured by copy ([expr.prim.lambda.capture]) in a lambda-expression that has an explicit object parameter whose type is dependent ([dcl.fct]),

• (3.7) the identifier __func__ ([dcl.fct.def.general]), where any enclosing function is a template, a member of a class template, or a generic lambda,

• (3.8) a conversion-function-id that specifies a dependent type, or

• (3.9) dependent

4 Expressions of the following form are value-dependent:

sizeof ... ( identifier )
fold-expression

unless the identifier is a structured binding pack whose initializer is not dependent.

- __cpp_­structured_­bindings 201606L
+ __cpp_­structured_­bindings 2024XXL