Расширить класс scala, который распространяется по заказу

Question

У меня возникли проблемы с расширением базового класса, который расширяет упорядоченный [Base]. Мой производный класс не может расширять Ordered [Derived], поэтому его нельзя использовать в качестве ключа в TreeMap. Если я создам TreeMap [Base], а затем просто переопределяю сравнение в Derived, которое работает, но это не то, что я хочу. Я хотел бы иметь возможность иметь производный класс в качестве ключа. Есть ли способ обойти это?

case class A(x: Int) extends Ordered[A] { 
    def compare(that: A) = x.compare(that.x) 
} 

// Won't compile 
// case class B(val y : Int) extends A(1) with Ordered[B] { 
// def compare(that: B) = x.compare(that.x) match { 
//  case 0 => y.compare(that.y) 
//  case res => res 
// } 
// } 

// Compiles but can't be used to define a TreeMap key 
case class B(y: Int) extends A(1) { 
    override def compare(that: A) = that match { 
    case b: B => x.compare(b.x) match { 
     case 0 => y.compare(b.y) 
     case res => res 
    } 
    case _: A => super.compare(that) 
    } 
} 

def main(args: Array[String]) { 
    TreeMap[B, Int]() // Won't compile 
} 

Редактировать

This discussion в списке рассылки кажется Scala очень актуальным, но она теряет меня немного.

Answer 1

Вы можете использовать преобразование типа из B в упорядоченном [B]:

class OrderedB(me : B) extends Ordered[B]{ 
    def compare(that: B) = me compare that 
} 
collection.immutable.TreeMap.empty[B, Int](new OrderedB(_)) 

Я думаю, что B всегда должен быть подтипом А, подразумевает Орден [A] whoes типа А инвариантно. Он не может определить второй метод сравнения для реализации Order [B] с тем же типом, что и метод сравнения из Ordered [A].

В качестве альтернативы можно определить неявные версии типа из В упорядоченном [B]:

implicit def orderedA2orderedB[B <: A with Ordered[A]](b : B) : Ordered[B] = b.asInstanceOf[Ordered[B]] 
collection.immutable.TreeMap[B, Int]() 

Это должно быть действительным. Я не знаю, как выразить это в системе типов без бросков.

Answer 2

Вы можете поместить неявное упорядочение [B] в объеме где-то, как это:

object BOrdering extends Ordering[B] { 
    def compare(a: B, b: B) = a.compare(b) 
    } 
    implicit val bo = BOrdering 
    TreeMap[B, Int]() // Now it works! 

---

EDIT: Это только в Scala 2.8 (спасибо, Кен)

Answer 3

Значение Ordered принимает параметр. Параметр типа, предоставленный, но он работает так же, как и любой другой параметр. Когда вы увеличиваете его дважды, в базовом классе и в подклассе, вы не «импортируете» две версии Ordered. Вместо этого происходит линеаризация классов, и вы импортируете ее только один раз. По этой причине вы не можете передать ему два разных параметра.

Теперь, есть причина, почему TreeMap не требует subclass из Ordered, просто переход от вашего класса к Ordered его. Именно такие вещи возможны. Вместо того, чтобы распространять эти вещи напрямую, вы должны имплицировать:

scala> class A(val x: Int) 
defined class A 

scala> class B(x : Int, val y : Int) extends A(x) 
defined class B 

scala> import scala.collection.immutable.TreeMap 
import scala.collection.immutable.TreeMap 

scala> class AOrd(a: A) extends Ordered[A] { 
    | def compare(that: A) = a.x.compare(that.x) 
    | } 
defined class AOrd 

scala> object AOrd { 
    | implicit def toAOrd(a: A) = new AOrd(a) 
    | } 
defined module AOrd 

scala> class BOrd(b: B) extends Ordered[B] { 
    | def compare(that: B) = b.x.compare(that.x) match { 
    |  case 0 => b.y.compare(that.y) 
    |  case res => res 
    | } 
    | } 
defined class BOrd 

scala> object BOrd { 
    | implicit def toBOrd(b: B) = new BOrd(b) 
    | } 
defined module BOrd 

scala> import AOrd._ 
import AOrd._ 

scala> import BOrd._ 
import BOrd._ 

scala> TreeMap[B, Int]() 
res1: scala.collection.immutable.SortedMap[B,Int] = Map()