Perché TREST in Tupla <T1... TRest> non è vincolato?

Question

In una tupla, se si dispone di più di 7 elementi, è possibile fornire un ottavo elemento che è un'altra tupla e definire fino a 7 elementi, quindi un'altra tupla come ottavo, avanti e indietro lungo la linea. Tuttavia, non vi è alcun vincolo sull'ottavo elemento in fase di compilazione. Ad esempio, questo è il codice legale per il compilatore:

var tuple = new Tuple<int, int, int, int, int, int, int, double> 
       (1, 1, 1, 1, 1, 1, 1, 1d); 

Anche se la documentazione intellisense dice che Trest deve essere una tupla. Non si ottiene alcun errore durante la scrittura o la compilazione del codice, non si manifesta fino al runtime sotto forma di ArgumentException.

È possibile implementare una tupla in pochi minuti, completa di un ottavo elemento con vincolo Tupla. Mi chiedo solo perché è stato interrotto dall'attuale implementazione? È forse un problema di compatibilità diretta in cui potrebbero aggiungere più elementi con un ipotetico C# 5?

versione corta del ruvida implementazione

interface IMyTuple { } 

class MyTuple<T1> : IMyTuple 
{ 
    public T1 Item1 { get; private set; } 
    public MyTuple(T1 item1) { Item1 = item1; } 
} 

class MyTuple<T1, T2> : MyTuple<T1> 
{ 
    public T2 Item2 { get; private set; } 
    public MyTuple(T1 item1, T2 item2) : base(item1) { Item2 = item2; } 
} 

class MyTuple<T1, T2, TRest> : MyTuple<T1, T2> where TRest : IMyTuple 
{ 
    public TRest Rest { get; private set; } 
    public MyTuple(T1 item1, T2 item2, TRest rest) 
     : base(item1, item2) 
    { 
     Rest = rest; 
    } 
} 

...

var mytuple = new MyTuple<int, int, MyTuple<int>> 
       (1, 1, new MyTuple<int>(1)); // legal 
var mytuple2 = new MyTuple<int, int, int>(1, 2, 3); // illegal at compile time 

Answer 1

L'ipotetica ITuple vincolo non sarebbe davvero vincolare ad essere una tupla [1], è vero ? Solo una classe che implementa ITuple.

[1] - Sto definendo "tupla" come una delle classi Tuple<> fornite da BCL.

Answer 2

È una limitazione del sistema di tipi. ITuple è un'interfaccia interna. Se si trattasse di un vincolo generico, dovrebbe essere pubblico, il che consentirebbe a tutti di implementare il proprio ITuple che non potrebbe avere nulla a che fare con le tuple. Limitare l'interno consente al team di BCL di garantire che si tratti di una sorta di tupla, ma i risultati in TRest sono un po 'meno precompilati rispetto a quelli che potrebbero essere.