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;".

template<int> struct X { using type = int; };
template<typename T> void f() {
  struct Y { int a, b; };
  auto [...v] = Y();
  X<sizeof...(v)>::type x; // need typename or no?
}

struct Z { int a, b; };
template <typename T> void g() {
  auto [...v] = Z();
  X<sizeof...(v)>::type x; // typename unnecessary
}

struct C
{
  int i;
  long l;
};

template<typename T>
struct D {
  template<int J>
  static int f(int);
};

template<>
struct D<long> {
  static int f;
};

auto [ ... v ] = C{ 1, 0 };
auto x = ( ... + (D<decltype(v)>::f<1>(2)) );

struct C { int j; long l; };

int g() {
    auto [ ... i ] = C{ 1, 2L };
    return ( [c = i] () {
        if constexpr (sizeof(c) > sizeof(long)) {
            static_assert(false); // error?
        }

        struct C {
            // error, not templated?
            int f() requires (sizeof(c) == sizeof(int)) { return 1; }

            // error, not templated?
            int f() requires (sizeof(c) != sizeof(int)) { return 2; }
        };
        return C{}.f();
    } () + ...  + 0 );
}

// error?
int v = g();

struct C { int j; long ; };

int g() {
    auto [ ... i ] = C{ 1, 2L };

    if constexpr (sizeof...(i) == 0) {
        static_assert(false); // #1
    }

    return (
      // E1
      []{
          if constexpr (sizeof(int) == 0) {
              static_assert(false); // #2
          }
          return 1;
      }()
      *
      // E2
      [c=i]{
          if constexpr (sizeof(c) > sizeof(long)) {
              static_assert(false); // #3
          }

          if constexpr (sizeof(int) == 0) {
              static_assert(false); // #4
          }

          return 2;
      }()
    + ... + 0)
}

void foo() {
    auto [...xs] = C();
    s0;
    s1;
    s2;
}

void foo() {
    auto [...xs] = C();
    [&](auto... xs){
        s0;
        s1;
        s2;
    }(xs...);
}

- 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 inhabit a block scope.

5 The type of a function is determined using the following rules. The type of each parameter (including function parameter packs), is determined from its own parameter-declaration ([dcl.decl]). After determining the type of each parameter, any parameter of type “array of T” or of function type T is adjusted to be “pointer to T”. After producing the list of parameter types, any top-level cv-qualifiers modifying a parameter type are deleted when forming the function type. The resulting list of transformed parameter types and the presence or absence of the ellipsis or a function parameter pack is the function’s parameter-type-list.

[Note 3: This transformation does not affect the types of the parameters. For example, int(*)(const int p, decltype(p)*) and int(*)(int, const int*) are identical types. — end note]

[ Example 1:

  void f(char*);                  // #1
  void f(char[]) {}               // defines #1
  void f(const char*) {}          // OK, another overload
  void f(char *const) {}          // error: redefines #1

  void g(char(*)[2]);             // #2
  void g(char[3][2]) {}           // defines #2
  void g(char[3][3]) {}           // OK, another overload

  void h(int x(const int));       // #3
  void h(int (*)(int)) {}         // defines #3

+ void k(int, int);               // #4
+ void m() {
+   struct C { int i, j; };
+   auto [... elems] = C{};
+   void k(decltype(elems)...);   // redeclares #4
+ }

— end example ]

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. The optional attribute-specifier-seq of an attributed-identifier sb-identifier appertains to the structured binding so introduced. 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. 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 3:

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];
+ auto [a, ...b, c] = g();      // 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] = g();           // e is a pack referring to the four elements of the array

— 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.

7a An implicit template region is a subregion of a block scope. An implicit template region is a template definition. At the end of an implicit template region, it is immediately instantiated ([temp.pre]). A declaration of a structured binding pack ([dcl.struct.bind]) that is not a templated entity (see below) introduces an implicit template region that includes the declaration of the structured binding pack and ends at the end of the scope that the structured binding declaration inhabits.

8 An entity is templated if it is

• (8.1) a template,
• (8.2) an entity defined ([basic.def]) or created ([class.temporary]) in a templated entity,
• (8.3) a member of a templated entity,
• (8.4) an enumerator for an enumeration that is a templated entity, or
• (8.5) the closure type of a lambda-expression ([expr.prim.lambda.closure]) appearing in the declaration of a templated entity. , or

• (8.6) an entity defined or created within an implicit template region.

[ Note 1: A local class, a local or block variable, or a friend function defined in a templated entity is a templated entity. — end note ]

[ Example 4: The following example assumes that char and int have different size.

struct C { char j; int l; };

int g() {
    auto [ ... i ] = C{ 'x', 42 }; // #1
    return ( [c = i] () {
        // The local class L is a templated entity because
        // it is defined within the implicit template region
        // created at #1.
        struct L {
            int f() requires (sizeof(c) == 1) { return 1; }
            int f() requires (sizeof(c) != 1) { return 2; }
        };
        return L{}.f();
    } () + ...  + 0 );
}

int v = g(); // OK, v == 3

— end example ]

[ Example 5:

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 ]

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, unless that pack is a non-type template parameter pack whose types are non-dependent,
• (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