Is there example of scala abstract type usage which is impossible to achieve with generics?

Question

There are two possible way to express abstraction over types.

abstract class Buffer {
  type T
  val element: T
}

rather that generics, e.g.

abstract class Buffer[T] {
  val element: T
}

I understand benefits in usability of using different approaches in different contexts. But I'm interest in examples where it is absolutely impossible to convert Abstract Type version to Generic version.

PS Code snippets are welcome.

Skid

Answer 1

Abstract types can be bound to path dependent types which is not possible with type parameters. Thus you can e.g. implement an abstract type with a concrete inner class:

trait A { type T }
class B extends A { class T }

or explicitly bind it to a path dependent type inside the classes scope:

class C { type T = this.type }
class D { object Q; type T = Q.type }

Wennerholn

Answer 2

Another difference: only type parameters can be used as self-types,

abstract class Buffer[T] { self: T =>
  val element: T
}

Mertens

Answer 3

// This is possible
trait M { type TM }
trait P[TP] extends M { type TM = TP }

// This is not
trait P[TP]
trait M extends P[TM] { type TM }

Wenwenceslaus

But what actually I can't do with generics? 1. example easily can be converted to "trait M[TM]; trait P[TP] extends M[TP]". 2. Simply does not compile so nothing to convert... – Skid