Scala：创建迫使类重新实现某些方法的特性

Question

我试图实现一个特性，强制每个扩展它的类（不是抽象的）实现某些方法（即使它们已经存在于超类中）。具体来说，它应该是这样的：

trait Debugable {

  override def hashCode(): Int = ???

  override def equals(obj: Any): Boolean = ???

  override def toString: String = ???

}

这就是它的特点，也是它的实现：

class TestClass {

}

object TestClass{
  def main(args: Array[String]): Unit = {
    val t = new TestClass
    println(t)
  }
}

上述代码在理想情况下不应编译（因为可调试类不实现所需的方法）。实际上，这不仅会编译，而且不会抛出运行时异常（它只接受对象类的默认实现）。

到目前为止，没有任何东西能够产生预期的行为。我认为宏可能会有所帮助，但我不确定宏是否可以表达以下内容：

foreach class
     if class.traits.contains(debugable)
         return class.methods.contains(toString)

我知道我可以让一些外部脚本进行检查，并将其与gradle编译任务捆绑在一起，但我希望有一个解决方案可以作为项目本身的一部分来实现（因为这将使它独立于使用的构建管道，而且它应该比编写一个爬行整个源代码的脚本更简单、更容易维护/扩展）

Answer 1

基于此，我编写了以下内容，满足了我的需求，并覆盖了默认实现：

trait Debuggable_Helper[T]{
  def hashCode(v: T): Int
  def equals(v: T, b: Any): Boolean
  def toString(v: T): String

}

trait Debuggable[T] extends Debuggable_Helper [Debuggable [T]]{
  override def hashCode(): Int = hashCode(this)
  override def equals(b: Any): Boolean = equals(this, b)
  override def toString(): String = toString(this)

}

class Foo extends Debuggable[Foo]{
  def hashCode(v: Debuggable[Foo]) = 42
  def equals(v: Debuggable[Foo], b: Any) = true
  def toString(v: Debuggable[Foo]) = "woohoo"

}
class Qux extends Foo with Debuggable[Qux] //does not compile


object Test{
  def main(args: Array[String]): Unit = {
    println(new Foo)   // OK - prints 'woohoo'
  }
}

Answer 2

在我看来，你应该把它抽象化。

// Start writing your ScalaFiddle code here
trait Debugable {
  def debugHashCode:Int
  def debugEquals(obj: Any): Boolean
  def debugToString: String

  override def hashCode(): Int = debugHashCode
  override def equals(obj: Any): Boolean = debugEquals(obj)
  override def toString: String = debugToString
}
//this will not compile
class TestClass extends Debugable { }
//this is OK but you need to implement 3 methods later :)
abstract class TestClass2 extends Debugable {}

https://scalafiddle.io/sf/bym3KFM/0

宏应该是你最后尝试的东西。

Answer 3

这是接近它（当然是一个改进，比我有），但它并没有完全做到我想要的。如果我有一个类的“链”，那么链的顶端实现这些方法就足够了。

类型类方法可以帮助实现这一点，例如，

trait Debuggable[T] {
  def hashCode(v: T): Int
  def equals(v: T, b: Any): Boolean
  def toString(v: T): String
}

class Foo
class Bar
class Qux extends Foo

object Debuggable {
  implicit val fooDebuggable: Debuggable[Foo] = new Debuggable[Foo] {
    def hashCode(v: Foo) = 42
    def equals(v: Foo, b: Any) = true
    def toString(v: Foo) = "woohoo"
  }
  implicit val barDebuggable: Debuggable[Bar] = new Debuggable[Bar] {
    def hashCode(v: Bar) = 24
    def equals(v: Bar, b: Any) = false
    def toString(v: Bar) = "boohoo"
  }
}

import Debuggable._
def debug[T](v: T)(implicit ev: Debuggable[T]) = ???
debug(new Foo)   // OK
debug(new Bar)   // OK
debug(new Qux)   // Error despite Qux <:< Foo