如何在使用trait覆盖方法时调用父类方法

Question

看起来可以通过以下方式更改类上具有trait的方法的实现：

trait Abstract { self: Result =>
    override def userRepr = "abstract"
}

abstract class Result {
    def userRepr: String = "wtv"
}

case class ValDefResult(name: String) extends Result {
    override def userRepr = name
}

val a = new ValDefResult("asd") with Abstract
a.userRepr

这里提供现场代码：http://www.scalakata.com/52534e2fe4b0b1a1c4daa436

但是现在我想要调用函数的上一个或超级实现，如下所示：

trait Abstract { self: Result =>
    override def userRepr = "abstract" + self.userRepr
}

或者

trait Abstract { self: Result =>
    override def userRepr = "abstract" + super.userRepr
}

然而，这些替代方案均无法编译。有任何想法如何实现吗？

- jedesah

---

可能是在Scala中的自类型特质中调用超类上的方法的重复问题。 - Suma

Answer 1

这就是我想要的答案。感谢Shadowlands指引我使用Scala的abstract override特性。

trait Abstract extends Result {
    abstract override def userRepr = "abstract " + super.userRepr
}

abstract class Result {
    def userRepr: String = "wtv"
}

case class ValDefResult(name: String) extends Result {
    override def userRepr = name
}

val a = new ValDefResult("asd") with Abstract
a.userRepr

这里提供了实时代码： http://www.scalakata.com/52536cc2e4b0b1a1c4daa4a4

对于这个令人困惑的示例代码，我正在编写一个处理Scala AST的库，但并没有足够的灵感来更改名称。

- jedesah

Answer 2

我不知道您是否有权进行以下更改，但是您想要的效果可以通过引入一种额外的特质（我将其称为Repr）并在Abstract特质中使用abstract override来实现：

trait Repr {
    def userRepr: String
}

abstract class Result extends Repr {
    def userRepr: String = "wtv"
}

case class ValDefResult(name: String) extends Result {
    override def userRepr = name
}

trait Abstract extends Repr { self: Result =>
    abstract override def userRepr = "abstract-" + super.userRepr // 'super.' works now
}

您现在的示例用法如下：

scala> val a = new ValDefResult("asd") with Abstract
a: ValDefResult with Abstract = ValDefResult(asd)

scala> a.userRepr
res3: String = abstract-asd

- Shadowlands

---

虽然我不认为我需要在我的特定情况下添加Repr trait，但是感谢您指出了Scala中的抽象覆盖功能，让我朝着正确的方向前进。我找到了这篇文章来解释它：http://www.artima.com/scalazine/articles/stackable_trait_pattern.html - jedesah

非常好的解决方案，但提供了一个更低的基础特征称为 Repr 来包含需要被覆盖的方法，做得好。 - Abimbola Esuruoso

Answer 3

abstract override是一种机制，也称为可堆叠特质。值得注意的是，线性化计算很重要，因为它决定了super的含义。

这个问题是关于self-type与扩展的规范问答的一个很好的补充。

当继承与self-types不明确时：

scala> trait Bar { def f: String = "bar" }
defined trait Bar

scala> trait Foo { _: Bar => override def f = "foo" }
defined trait Foo

scala> new Foo with Bar { }
<console>:44: error: <$anon: Foo with Bar> inherits conflicting members:
  method f in trait Foo of type => String  and
  method f in trait Bar of type => String
(Note: this can be resolved by declaring an override in <$anon: Foo with Bar>.)
              new Foo with Bar { }
                  ^

显然，你可以进行选择：

scala> new Foo with Bar { override def f = super.f }
res5: Foo with Bar = $anon$1@57a68215

scala> .f
res6: String = bar

scala> new Foo with Bar { override def f = super[Foo].f }
res7: Foo with Bar = $anon$1@17c40621

scala> .f
res8: String = foo

或者

scala> new Bar with Foo {}
res9: Bar with Foo = $anon$1@374d9299

scala> .f
res10: String = foo

- som-snytt