Esiste un esempio di utilizzo di scala astratta che è impossibile ottenere con i generici?

Question

Esistono due modi per esprimere l'astrazione sui tipi.

abstract class Buffer { 
    type T 
    val element: T 
} 

piuttosto che generici, ad es.

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

Comprendo i vantaggi nell'usabilità dell'utilizzo di approcci diversi in diversi contesti. Ma sono interessato ad esempi in cui è assolutamente impossibile convertire la versione di Abstract Type in quella di Generic.

Gli snippet di codice PS sono i benvenuti.

Answer 1

I tipi astratti possono essere associati a tipi dipendenti dal percorso che non è possibile con i parametri di tipo. Quindi puoi ad es. implementare un tipo astratto con una classe interna cemento:

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

o esplicitamente associarlo a un percorso di tipo dipendente all'interno della portata classi:

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

Answer 2

// 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 } 

Answer 3

Un'altra differenza: unico tipo parametri possono essere utilizzati come auto- tipi,

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