Question

这只是一个基本的例子，但是可以重写最后一个特性以避免使用2型（T，U）设置，以某种方式通过使用M来提取或推断T？我更多地询问没有显式对象的类型系统，但也许这是唯一的方法？

trait Data[T]{
  val x:T
}

trait Meta[T<:Data[T]]{
  val m:T
}

trait Overall[T, M<:Meta[T] ] {
 def review(t:T): M
}

//assume we want to work with the nested data type Int
case class Helper extends Overall[Int,Meta[Int]]

我要问的错误说明：

//extract T by however Overall is finally defined?
trait Overall[ M<:Meta[T] ] {
    def review(t:T): M
}

case class Helper extends Overall[Meta[Int]]

谢谢

Answer 1

我认为你不能直接得到你想要的类型。但是，您可以通过将类型设置为类型变量来隐藏签名中的类型。

trait Overall[T] {
  type M <: Meta[T]
  def review(t:T): M
}

case class Helper extends Overall[Int] {
  override type M = Meta[Int]
  def review(t: Int): Meta[Int] = null;
}

您仍然必须在子类中声明它，但在使用该类时则不然。

Answer 2

或者您使用Meta的类型成员：

trait Meta {
  type T <: Data[T] 
  val m: T
}

trait Overall[M <: Meta] {
  def review(t: M#T): M
}

case class IntData(x: Int) extends Data[Int]

case class Helper extends Overall[Meta { type T = IntData }] {
  def review(t: IntData) = ???
}

但是，您确定要定义T <: Data[T]吗？因为这没什么意义：

case class Helper extends Overall[Meta { type T = IntData }] {
  def review(t: IntData) = new Meta {
    type T = IntData
    val m = IntData(1234)
  }
}

<console>:14: error: overriding type T in trait Meta with bounds <: Data[this.T];
 type T has incompatible type
           type T = IntData
                ^

这样，定义Data类型的唯一可能就是

case class IntData() extends Data[IntData] { val x = this } // !?!

case class Helper extends Overall[Meta { type T = IntData }] {
  def review(t: IntData) = new Meta {
    type T = IntData
    val m = IntData()
  }
}

可能这不是你想要的。

提取嵌套类型而不传递两次？

2 个答案: