使用 @uncheckedVariance 强制 Scala 抽象类型的协方差

如何解决使用 @uncheckedVariance 强制 Scala 抽象类型的协方差

在很多地方都很好地介绍了差异主题，但不幸的是，我没有找到任何关于抽象类型的主题。

然后为了理解集合，我写了以下内容

trait Collectionops[+A,+C] {
  this: C =>

  type CC[B] <: BasicColl[B] // Invariant position

  def filter(f: A => Boolean): C

  def map[B](f: A => B): CC[B] // CC is in a covariant position but declared invariant via abstract type 
}

trait BasicColl[+A] extends Collectionops[A,BasicColl[A]] {
  type CC[B] = BasicColl[B] // this is the problem,the equality
  // But if i let inequality: type CC[B] <: BasicColl[B] 
}

// Do not compile due to prevIoUs equality and invariance on CC
trait BasicColl2[+A] extends BasicColl[A] with Collectionops[A,BasicColl2[A]] {
  type CC[B] = BasicColl2[B]
  // But if i let the prevIoUs inequality i can writte type CC[B] <: BasicColl2[B] 
}

trait Test_With_Abstract_Type_Equality {

  // Only BasicColl extist
  def coll1: BasicColl[Int]
  // We have exact type due to equality of CC with BasicColl
  def mapped: BasicColl[Double] = coll1.map(_.todouble)

  // But no specialized inhéritence possible

}
trait Test_With_Abstract_Type_Inequality {

  def coll1: BasicColl[Int]
  // We have abstract type due to inequality of CC with BasicColl
  def mappedWithAbstractTypeDef: BasicColl[Int]#CC[Double] = coll1.map(_.todouble)

  // BasicColl2 can exist
  def coll2: BasicColl2[Int]
  // We have abstract type due to inequality of CC with BasicColl2
  def mappedWithAbstractTypeDef2: BasicColl2[Int]#CC[Double] = coll2.map(_.todouble)

}

Scala 模式不使用抽象类型，而是直接使用协变参数化类型 CC，如下所示

trait IterableOnceOps[+A,+CC[_],+C]

协方差具有促进特征混合的优势。

但是在类型参数级别使用这种类型的更高级会阻止对具有超过 1 个参数化类型的类的任何扩展，其中使用抽象类型允许扩展到更复杂的类，但代价是将抽象类型作为输出。 在这里，我尝试过这一点，但我对它的风险没有足够的信心。

// RedeFinition
trait Collectionops[+A,+C] {
  this: C =>

  type CC[B] <: BasicColl[B] // Invariant position

  def filter(f: A => Boolean): C

  def map[B](f: A => B): CC[B] // but CC is in a covariant position 
}
// RedeFinition
trait BasicColl[+A] extends Collectionops[A,BasicColl[A]]


trait CollectionopsLocked1[+A,+CCC[B] <: BasicColl[B],+C] extends Collectionops[A,C] {
  this: C =>

  type CC[B] = CCC[B] @uncheckedVariance // this is my question

  // If i use CC ONLY in covariant position is there any risk ?

}

trait BasicColl2[+A] extends BasicColl[A] with CollectionopsLocked1[A,BasicColl2,BasicColl2[A]]
trait BasicColl3[+A] extends BasicColl2[A] with CollectionopsLocked1[A,BasicColl3,BasicColl3[A]]

trait Test {

  def coll1: BasicColl[Int]
  def mappedWithAbstractTypeDef: BasicColl[Int]#CC[Double] = coll1.map(_.todouble)

  // BasicColl2 can exist
  def coll2: BasicColl2[Int]
  def mapped2: BasicColl2[Double] = coll2.map(_.todouble)

  // BasicColl3 can exist
  def coll3: BasicColl3[Int]
  def mapped3: BasicColl3[Double] = coll3.map(_.todouble)

}

更一般地说，在协方差/逆变合法的地方使用 @uncheckedVariance 是否有任何风险？