Overriding a repeated class parameter in Scala?

Question

Section 4.6.2 of the Scala Language Specification Version 2.8 describes repeated parameters and says:

The last value parameter of a parameter section may be suffixed by “*”, e.g. (..., x:T*). The type of such a repeated parameter inside the method is then the sequence type scala.Seq[T].

However, this code:

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

give an error when compiled:

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

The compiler seems to indicate that A* is a distinct type from Seq[A].

Investigating the actual class of aSeq in this case shows it to be an instance of scala.collection.mutable.WrappedArray$ofRef but even the following code fails to compile with the same message:

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

So the question is, how do I go about overriding a member defined by a repeated parameter on the class?

In case you're wondering where this is coming from, that is exacly what scala.xml.Elem does to override the child method in scala.xml.Node.

I would suggest not using repeated parameters as vals in a class (I am a bit surprised it compiles at all). Instead have class B(val aSeq: Seq[A]) extends A and if you want to have syntax B(a1, a2, ...) available, add it in the companion object: object B {def apply(aSeq : A*) = new B(aSeq)}. — Alexey Romanov
It's not my code that's using it. As I said at the end of the post, the repeated param is used by the scala.xml.Elem subclass of scala.xml.Node. I don't have the option of changing it. — DougC
Ah, I misread it. Just checked scala.xml.Node and not scala.xml.Elem. — Alexey Romanov
I tried override val seq: Int* = Seq(1,2) and override val seq = Seq(1,2): _*. Unfortunately, neither works. I suspect it may be impossible, but hopefully this is wrong. — Alexey Romanov

huynhjl huynhjl · Accepted Answer · 2011-04-01T13:32:11

Your issue can be summarized as:

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 }

The methods have different types. The spec says (emphasis mine):

The type of such a repeated parameter inside the method is then the sequence type scala.Seq[T]

As Int* and Seq[Int] aren't inside the method, this particular sentence does not apply.

Interestingly, this following code shows that the methods have different types before erasure but the same after:

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 }

So the question then becomes, why your B class can extend your A abstract class. There may be an inconsistency in the spec there. I don't know...

Edit: I re-read the spec and I can't figure out if there is anything related to repeated parameters and overriding. There does not seem to be anything about return type of repeated parameters, which is what you get for the val aSeq accessor method.

I think Mark's answer is a perfectly valid approach. In case you can't follow it, you can use the following workaround:

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

So for instance:

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/>: _*) }

Then:

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

Overriding a repeated class parameter in Scala?

3 Answers