如何从Scala中的重写方法返回正确的类型？

Question

As a newbie in Scala, I have stumbled on this seemingly easy point of SubClassing and Overriding methods.

I have specialized a Set thus:

    class SpecializedSet [T](s:Int, b: Boolean) (implicit ordering: Ordering [T]) extends TreeSet [T] { 
      override def + (t: T): SpecializedSet [T] = {

           if (this.isEmpty) {

              s = s + 1

              // I want to add an element to the Set
              super.+ (t) 

           }
           ....
       }

At the site of using this class, I do:

       class Driver {

         var e = new SpecializedSet [MyEarlierDefinedType](3,false);

         ......

         val elem1 = new MyEarlierDefinedType()

         e = e + eleme1 

         ......
     }

The compiler immediately complains:

type mismatch; found : scala.collection.immutable.TreeSet[T] required: org.personal.exercises.SpecializedSet[T]

I understand that the overridden '+' method has to return a 'SpecializedSet' type - a Subtype - and a mere call to super.+() doesn't achieve that.

It is not the same TreeSet that super.+() returns, it is a new TreeSet created in its place. I am thinking that I have to now create a new instance of SpecializedSet() myself, using this new TreeSet. I am stuck here. How do I create a new SpecializedSet(), using a TreeSet which is its Supertype ? What is the idiom in the Scala world to use in such cases? Is use of asInstanceOf() the most appropriate and short answer here? But, isn't use of that method discouraged all along?

Do I have to create a companion object of SpecializedSet defining an apply() method therein? Alternatively, do I have to go much deeper and use the concept of Traits described in Scala: how to write method that returns object typed to implementation type of receiver and Subclasses and return types and other related links? Or, follow the more complicated direction of creating Builder s like in http://www.scala-lang.org/docu/files/collections-api/collections-impl.html ?

I have gone through this question (and answers) too: Extending a Scala collection - and they are certainly useful - but somehow I think there is more to it than I have understood. For example, one of the solutions in that link is to explicitly mention the type of Baseclass in the function signature, thus:

      override def + (t: T): TreeSet [T] = { // instead of SpecializedSet 
             ......

But, then isn't it a violation of the expectation of the caller of the method, in a way? I am confused.

Does the solution have to be so involved as outlined in these links? What is the obvious point that I am missing? Any pointer will be helpful. I have searched to quite a good extent but if my question is a duplicate, please bear with me and direct me.

Answer 1

I would prefer to extend the corresponding trait and use the class through composition instead of direct inheritance:

class SpecializedSet[T](s: Int, b: Boolean)(implicit ordering: Ordering[T]) extends SortedSet[T] {
  private var ts = new TreeSet[T]()
  override def +(t: T): SpecializedSet[T] = {
    ts += t
    this
  }
  override def -(t: T): SpecializedSet[T] = {
    ts -= t
    this
  }
  override def contains(t: T): Boolean = ts.contains(t)
  override def iterator(): Iterator[T] = ts.iterator
  override def ordering(): Ordering[T] = ts.ordering
  override def rangeImpl(from: Option[T], until: Option[T]) = ts.rangeImpl(from, until)
}

I think this approach is more newbie friendly since it avoids direct class inheritance and (direct) calls to super. The drawback of this very simple solution is that we introduced mutability. This could be solved by redesigning the constructor a bit so that it is possible to make the member a val and really return a new modified SpecializedSet instance instead of this .