在 Scala 中重写重复的类参数？

Question

Scala 语言规范 2.8 版的第 4.6.2 节描述了重复参数并表示：

参数部分的最后一个值参数可以带有“*”后缀，例如(..., x:T*)。方法内此类重复参数的类型就是序列类型 scala.Seq[T]。

然而，这段代码：

abstract class A { def aSeq : Seq[A] }
class B(val aSeq : A*) extends A
class C extends B { override val aSeq :Seq[A] = Seq() }

编译时出现错误：

overriding value aSeq in class B of type A*;  value aSeq has incompatible type

编译器似乎表明 A* 是与 Seq[A] 不同的类型。

在这种情况下调查 aSeq 的实际类表明它是 scala.collection.mutable.WrappedArray$ofRef 的实例，但即使以下代码也无法编译并显示相同的消息：

class C extends B { override val aSeq  = new ofRef(Array[A]()) }

所以问题是，如何覆盖类中由重复参数定义的成员？

如果您想知道这是从哪里来的，这正是 scala.xml.Elem 用来重写 scala.xml.Node 中的 child 方法的方法。

Answer 1

您的问题可以概括为：

scala> class A { def aSeq(i: Int*) = 1 }
defined class A

scala> class B extends A { override def aSeq(i: Seq[Int]) = 2 }
<console>:6: error: method aSeq overrides nothing
       class B extends A { override def aSeq(i: Seq[Int]) = 2 }

方法有不同的类型。规范说（强调我的）：

方法内部的此类重复参数的类型就是序列类型 scala.Seq[T]

As Int* 和 Seq[Int]不在方法内部，这句话不适用。

有趣的是，下面的代码显示这些方法在擦除之前具有不同的类型，但在擦除之后具有相同的类型：

scala> class G { def aSeq(i:Int*) = 1; def aSeq(i:Seq[Int]) = 2 }
<console>:5: error: double definition:
method aSeq:(i: Seq[Int])Int and
method aSeq:(i: Int*)Int at line 5
have same type after erasure: (i: Seq)Int
       class G { def aSeq(i:Int*) = 1; def aSeq(i:Seq[Int]) = 2 }

因此问题就变成了，为什么您的 B 类可以扩展您的 A 抽象类。那里的规范可能存在不一致。我不知道...

编辑：我重新阅读了规范，但我无法弄清楚是否有任何与重复参数和覆盖相关的内容。似乎没有任何关于重复参数的返回类型的信息，这是您从 val aSeq 访问器方法中获得的。

我认为马克的回答是一个完全有效的方法。如果您无法遵循它，您可以使用以下解决方法：

class C extends B {
  private def aSeqHelper(a: A*) = a
  override val aSeq = aSeqHelper(Seq[A](): _*)
}

例如：

import scala.xml._
class ElemX extends Elem("pref", "label", <xml a="b"/>.attributes, TopScope) {
  private def childHelper(c: Node*) = c
  override val child = childHelper(<foo/><bar/>: _*) }

然后：

scala> new ElemX
res4: ElemX = <pref:label a="b"><foo></foo><bar></bar></pref:label>

Answer 2

xml.Elem的copy方法是这样使用的

def copy(
  prefix: String = this.prefix,
  label: String = this.label,
  attributes: MetaData = this.attributes,
  scope: NamespaceBinding = this.scope,
  child: Seq[Node] = this.child.toSeq
): Elem = Elem(prefix, label, attributes, scope, child: _*)

所以你可以重写B构造函数中的值

class C extends B(aSeq = Seq(): _*)

或者将其声明为类C的参数code>

class C(seq: Seq[A]) extends B(aSeq = seq: _*)

虽然我不确定它是否回答了你的问题！

Answer 3

该规范从来不允许重复类型以这种方式泄漏。编译器于 2011 年 7 月进行了更改以强制执行此操作。

有关更多背景信息，请查看票证中的评论：

https://issues.scala-lang .org/browse/SI-4176