Question

好的，所以，我知道我可以做以下事情：

trait MyTrait[T <: MyTrait[T]] { self: T =>
  val listOfT: List[T]
  def getFirst: T
  def getOne: T = if (listOfT.length > 0) getFirst else self
}

class MyClass extends MyTrait[MyClass] {
  override val listOfT: List[MyClass] = List[MyClass](this)
  override def getFirst: MyClass = listOfT.head
}

如果我希望MyTrait有一个伴侣对象，它看起来像：

object MyTrait{
  def doSomething[T <: MyTrait[T]](aninstance:T)= { ... }
}

所有看起来都很丑陋，我希望看到一个更好的方式，但是，现在我只想弄清楚，我如何从其他地方引用这种类型？例如：

case class Foo( anInstanceOfMyTrait: MyTrait[what goes here???] )

或者有更简单的方法吗？

Answer 1

查看您的评论似乎实际问题是，在您尝试参数化Foo时，您引用了两次MyTrait：

case class Foo[A <: MyTrait[A]](i:MyTrait[A])

请改为尝试：

case class Foo[A <: MyTrait[A]](i: A)

这反映了MyTrait.doSomething的定义方式，因此您可以将i传递给doSomething：

case class Foo[A<:MyTrait[A]](i: A)
val foo = new Foo[MyClass]( new MyClass )
MyTrait.doSomething( foo.i ) // This compiled OK

Answer 2

我让这个工作：

trait MyTrait[T <: MyTrait[T]] {
  def getFirst = this
}

class MyClass extends MyTrait[MyClass]

case class Foo[A <: MyTrait[A]](i: MyTrait[A])

object MyTrait {
  def doSomething[T <: MyTrait[T], U[X <: MyTrait[X]] <: MyTrait[X]](t: U[T]) =
    t.getFirst
}

val mc = new MyClass
val foo = Foo(mc)
MyTrait.doSomething(foo.i)

案例类字段中的递归类型参数

2 个答案: