Type system not allowing subtype as a type constructor - scala

Question

I'm trying to build the following type structure for a library I'm writing, and I'm having trouble with the type system.
CarLike
trait CarLike[T, C <: CarLike[T,C]] {
val parts: Seq[T]
def crash(other: C, speed: Int): C
//... other methods
}
SimpleCar
class SimpleCar[T](val parts: Seq[T]) extends CarLike[T, SimpleCar[T]] {
def crash(other: SimpleCar[T], speed: Int) = {
//Some logic to crash with the other car
val newParts = damage(parts) //parts have changed
new SimpleCar(newParts)
}
//...other methods
}
SportsCar
class SportsCar(val sParts: Seq[String]) extends SimpleCar[String](sParts){
override def crash(other: SimpleCar[String], speed: Int): SimpleCar[String] = {
//Some other logic for crashing a sport car
val newParts = damage(parts) //parts have changed
new SportsCar(newParts)
}
//...other methods
}
Crasher
case class Crasher[T, C <: CarLike[T,C]](
partsDamager: T => T,
carChecker: C => Seq[T]
/*... more parameters*/
){
def test(cycles:Int) = {
//Some logic to run a crash of two cars
}
}
Code
//...
val crasher = Crasher[String, SportsCar](
(s: String) => s.tail,
(c: SportsCar) => c.parts.filter(p => p.length > 0)
/*Many arguments*/
)
crasher.test(20)
//...
The idea is to allow the user of the library to be able to choose between using the default SimpleCar and implementing his own implementation of CarLike.
Also, users can choose the type for the car's parts. In this simple example the parts are String, but can easily be a custom class, which can be leveraged in the crash method of a custom class.
When compiling, I get the following compilation error:
type arguments [String,my.package.SportsCar] do not conform to method apply's type parameter bounds [T,C <: crashing.CarLike[T,C]]
val crasher = Crasher[String, SportsCar](
Clearly there's something I'm missing here. Why doesn't the compiler agree that SportsCar is a legal subtype of CarLike?

Answer 1

A SportsCar is not a CarLike[String, SportsCar], it is a CarLike[String, SimpleCar[String]]. Note that SportsCar extends SimpleCar[String], but that doesn't help, as CarLike is not covariant in C.
You can't really make CarLike covariant in C, as its crash method accepts a C. Instead, you can pass SimpleCar[String] to Crasher (after all, sports cars can crash with other cars, right?):
val crasher = Crasher[String, SimpleCar[String]](
s => s.tail,
c => c.parts.filter(p => p.length > 0)
)
Or, you can modify Crasher to take another type parameter:
case class Crasher[T, C <: CarLike[T, C], X <: C](partsDamager: T => T,
carChecker: X => Seq[T]) {
// ...
}
val crasher = Crasher[String, SimpleCar[String], SportsCar](
s => s.tail,
c => c.parts.filter(p => p.length > 0)
)