Aggregati variabili come lingua principale

Question

std::tuple è una bestia altamente caricata di modelli. Per accedere al n-esimo compilatore di membri è necessario eseguire numerose istanze di template, sebbene la sua natura semplice: l'accesso all'n-esimo membro dei dati della corrispondente struttura immaginaria. Sembra che std::tuple dovrebbe essere una caratteristica del linguaggio di base, qualcosa di simile a questo (pseudocodice):

template< typename ...types > 
struct/* or class, or even union */ V 
{ 
    types... V; // defines implicitly `operator [/*constant expression*/]` to access by index 
    // if more than one variadic parameter pack provided 
    // (during expanding of parameter pack of template 
    // parameters in specializations) then instead of 
    // `V` there can be specific data-member name (say, `x`), 
    // but still with `x.operator []` implicitly defined 

    // member functions and data members allowed 
}; 

template< typename ...types > 
V< std::decay_t<types>... > make_tuple(types &&... args) 
{ return {std::forward<types>(args)...}; } 
template< typename ...types > 
V< types &&... > forward_as_tuple(types &&... args) 
{ return {std::forward<types>(args)...}; } 
template< typename ...types > 
V< types &... > tie(types &... args) 
{ return {args...}; } 

C'è qualche proposta di qualcosa come lingua supportata variadic data-membri definizione di sintassi per le classi?

Answer 1

Vedere N4235 Selecting from Parameter Packs per un'idea correlata.

Questo potrebbe essere utile per std::tuple, ma sono più interessato a una funzionalità per semplificare la sua costruzione, non la selezione di membri (che è relativamente semplice).

La definizione di std::tuple è follemente complicata, per fare in modo che tutti i costruttori modellino correttamente le proprietà di tutti i membri (vedere N4064 per le modifiche più recenti in quell'area).

Quando si utilizza l'inizializzazione di aggregazione, il compilatore verifica automaticamente se ciascun membro dell'aggregato può essere costruito dai corrispondenti inizializzatori. Si verifica la presenza di costruttori idonei, siano essi explicit, accetta la relativa categoria lvalue/rvalue ecc

Quando si definisce un costruttore per std::tuple è deve essere molto complicato per garantire che solo le conversioni valide accadere, che explicit costruttori non sono usato quando non dovrebbero essere ecc.

Vorrei una funzionalità che rendesse molto più semplice generare automaticamente costruttori adatti a modellare la stessa semantica che si ottiene gratuitamente dall'inizializzazione degli aggregati.