Dotty无法使用抽象类型来推断带有类型参数特征的通用Scala函数的结果类型

一个简单的价值层次

想象一下这个简单的特征Value，其中每个实现类都具有value某种类型T。

trait Value {
  type T
  def value: T
}

我们有两个不同的实现类Int，String分别表示和。

case class IntValue(override val value: Int) extends Value {
  override type T = Int
}

case class StringValue(override val value: String) extends Value {
  override type T = String
}

键入值的安全选择

如果我们有一个List值，我们希望有一种类型安全的方式来选择特定类型的所有值。类Values及其配套对象可以帮助我们做到这一点：

object Values {
  private type GroupedValues = Map[ClassTag[_ <: Value], List[Value]]

  def apply(values: List[Value]): Values = {
    val groupedValues: GroupedValues = values.groupBy(value => ClassTag(value.getClass))
    new Values(groupedValues)
  }
}

class Values private (groupedValues: Values.GroupedValues) {
  // Get a List of all values of type V.
  def getValues[V <: Value : ClassTag] = {
    val classTag = implicitly[ClassTag[V]]
    groupedValues.get(classTag).map(_.asInstanceOf[List[V]]).getOrElse(Nil)
  }

  def getValue[V <: Value : ClassTag] = {
    getValues.head
  }

  def getValueOption[V <: Value : ClassTag] = {
    getValues.headOption
  }

  def getValueInner[V <: Value : ClassTag] = {
    getValues.head.value
  }
}

所有这些在Scala 2.13和Dotty 0.20.0-RC1中都可以正常工作，因此具有混合值列表…

val valueList = List(IntValue(1), StringValue("hello"))
val values = Values(valueList)

…我们可以选择元素并将它们返回为正确的类型-在编译时全部检查：

val ints: List[IntValue] = values.getValues[IntValue]
val strings: List[StringValue] = values.getValues[StringValue]

val int: IntValue = values.getValue[IntValue]
val string: StringValue = values.getValue[StringValue]

val intOption: Option[IntValue] = values.getValueOption[IntValue]
val stringOption: Option[StringValue] = values.getValueOption[StringValue]

val i: Int = values.getValueInner[IntValue]
val s: String = values.getValueInner[StringValue]

Option[T]在Dotty中选择失败的值

但是，如果我们添加此函数以选择值作为其T类型（即Int和String）并将其返回为Option…

class Values ... {
  ...
  def getValueInnerOption[V <: Value : ClassTag] = {
    getValues.headOption.map(_.value)
  }
}

…然后在Scala 2.13中一切正常：

val iOption: Option[Int] = values.getValueInnerOption[IntValue]
val sOption: Option[String] = values.getValueInnerOption[StringValue]

但是在Dotty 0.20.0-RC1中无法编译：

-- [E007] Type Mismatch Error: getValue.scala:74:29 
74 |  val iOption: Option[Int] = values.getValueInnerOption[IntValue]
   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |                             Found:    Option[Any]
   |                             Required: Option[Int]
-- [E007] Type Mismatch Error: getValue.scala:75:32 
75 |  val sOption: Option[String] = values.getValueInnerOption[StringValue]
   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |                                Found:    Option[Any]
   |                                Required: Option[String]

我们可以通过添加类型参数来解决问题，该参数getValueInnerOption将返回类型和抽象类型联系T在一起，并允许我们指定返回类型。

def getValueInnerOption[V <: Value {type T = U} : ClassTag, U]: Option[U] = {
  getValues.headOption.map(_.value)
}

不幸的是，这意味着我们将不得不在呼叫站点添加实际的类型T（即Int或String），这很遗憾，因为它只是样板。

val iOption: Option[Int] = values.getValueInnerOption[IntValue, Int]
val sOption: Option[String] = values.getValueInnerOption[StringValue, String]

Dotty中的错误或怎么办？

看起来Dotty已经知道什么是上限，T但是无法将该知识传播到函数的结果类型。由此可以看出，如果试图问一个String来自IntValue：

-- [E057] Type Mismatch Error: getValue.scala:75:39 
75 |  val wtf = values.getValueInnerOption[IntValue, String]
   |                                       ^
   |Type argument IntValue does not conform to upper bound Value{T = String} 

那么原始代码（不带type参数U）是可以在最终Scala 3.0中使用的东西吗，还是需要以其他方式编写？