ovariância na programação em nível de ti

Estou tentando criar tipos Tupla equivalentes aos da biblioteca Scala, apenas com o método: + que estende uma Tupla para uma Tupla pela adição do valor N + 1º - para que eu possa construir Tuplas recursivamente:

class Test {
  abstract class Tuple {
    //protected type Next[_] <: Tuple
    //def :+[T](p: T): Next[T]
  }

  case class Tuple0() extends Tuple {
    protected type Next[T] = Tuple1[T]
    def :+[T](p: T): Next[T] = Tuple1(p)
  }

  case class Tuple1[+T1](p1: T1) extends Tuple {
    protected type Next[T] = Tuple2[T1, T]
    def :+[T](p: T): Next[T] = Tuple2(p1, p)
  }

  case class Tuple2[+T1, +T2](p1: T1, p2: T2) extends Tuple {
    protected type Next[-T] = Nothing
    def :+[T](p: T): Next[T] = throw new IndexOutOfBoundsException();
  }
}

Isso compila, mas assim que descomente a definição de Tupla # Em seguida, recebo:

Test.scala:13: error: covariant type T1 occurs in invariant position in type [T]Test.this.Tuple2[T1,T] of type Next
    protected type Next[T] = Tuple2[T1, T]
                       ^
one error found

Por que é que? Você pode fornecer uma solução alternativa que me permita criar Tuplas (de tipos de valor misto e com segurança de tipo) recursivamente?

Obrigado

questionAnswers(2)

yourAnswerToTheQuestion