(In Scala,) Is there anything that can be done with generic type parameters of classes but not with abstract type members?

Question

It is clear that one cannot parametrize a method with abstract type members. However, is there any reason for the existence of generic type parameters for classes except for the convenience issue that types and instantiations can be written shorter, e.g. in the following abstracted List-ArrayList scenario:

Here, the parametrization is realized by an abstract type member:

trait base1 {
    type X
    def id(x: X): X
}
class extension1 extends base1 {
    override def id(x: X): X = x
}
val ext1: base1 { type X = Int } = new extension1 { type X = Int }
val y1 = ext1.id(0)

Here it is realized by a generic type parameter:

trait base2[X] {
    def id(x: X): X
}
class extension2[X] extends base2[X] {
    override def id(x: X): X = x
}
val ext2: base2[Int] = new extension2[Int]
val y2 = ext2.id(0)

The latter solution is more convenient and readable. This is important by itself but I am interested in the more general, i.e. semantic, perspective.

This interview with Martin Odersky is a great introduction but it does not seem to answer this question.

Thank you very much for any hint or explanation!

Answer 1

The book Programming Scala by Dean Wampler and Alex Payne gives a good overview about when to use type parameters vs. abstract type members.

In addition to not beeing able to parameterize methods (which can be a big restriction) there are two restrictions of abstract type members:

1. Abstract types can not be variance annotated (See p. 269) Meaning there is no equivalent to trait List[+T] or trait Function[-T,+R] with abstract type members.

2. Abstract types can lead to unjustified type errors with path-dependent types. There is an example for this on p. 272.