Scala 如何在返回类型中保留多态函数的参数类型

给定一个多态函数，如何匹配多态参数并返回相同类型的值而不诉诸显式强制转换

sealed trait Data
case class DString(s: String) extends Data
case class DInt(n: Int) extends Data

def double[D <: Data](d: D): D = d match {
  case DString(s) => DString(s ++ s)
  case DInt(n) => DInt(n + n)
}

密封特征数据
case类DString（s:String）扩展数据
案例类力（n:Int）扩展数据
def双[D数据串（s++s）
壳体力（n）=>力（n+n）
}

这会产生类型不匹配（发现

DString

/

DInt

，需要

D

）。

---

当输入类型明显等于输出类型时，为什么类型系统不接受这一点？

这似乎是一个问题的重新表述，通常使用F-有界多态性来解决。唯一的区别是，您希望在一个未在trait中定义的函数中保留您正在处理的类型

因此，我要做的是将

double

方法移动到

Data

特征中，并使用一个抽象类型成员：

sealed trait Data {
  type Self <: Data
  def double: Self
}

case class DString(s: String) extends Data {
  type Self = DString
  def double = DString(s ++ s)
}

case class DInt(n: Int) extends Data {
  type Self = DInt
  def double = DInt(n + n)
}

密封特征数据{
类型Self这似乎是对一个问题的重新表述，通常使用F-有界多态性来解决。唯一的区别是，您希望在一个没有在trait中定义的函数中保留您正在处理的类型

因此，我要做的是将
double
方法移动到
Data
特征中，并使用一个抽象类型成员：

sealed trait Data {
  type Self <: Data
  def double: Self
}

case class DString(s: String) extends Data {
  type Self = DString
  def double = DString(s ++ s)
}

case class DInt(n: Int) extends Data {
  type Self = DInt
  def double = DInt(n + n)
}

密封特征数据{
键入Self这可能是使用方法重载的合法位置：

def double(ds: DString) = DString(ds.s ++ ds.s)
def double(di: DInt) = DInt(di.n + di.n)

您还可以使用类型类：

abstract class DataDoubler[A <: Data] {
  def double(a: A): A
}

implicit object DStringDoubler extends DataDoubler[DString] {
  def double(ds: DString) = DString(ds.s ++ ds.s)
}

implicit object DIntDoubler extends DataDoubler[DInt] {
  def double(di: DInt) = DInt(di.n + di.n)
}

def double[A <: Data](a: A)(implicit dd: DataDoubler[A]): A = dd.double(a)

抽象类DataDoubler[A这可能是使用方法重载的合法位置：

def double(ds: DString) = DString(ds.s ++ ds.s)
def double(di: DInt) = DInt(di.n + di.n)

您还可以使用类型类：

abstract class DataDoubler[A <: Data] {
  def double(a: A): A
}

implicit object DStringDoubler extends DataDoubler[DString] {
  def double(ds: DString) = DString(ds.s ++ ds.s)
}

implicit object DIntDoubler extends DataDoubler[DInt] {
  def double(di: DInt) = DInt(di.n + di.n)
}

def double[A <: Data](a: A)(implicit dd: DataDoubler[A]): A = dd.double(a)

抽象类数据倍增器[A]