Clases concretas con miembros de tipo abstracto

Question

Dadas las siguientes características y clase. ¿Por qué esta compilación? ¿Se puede usar esto realmente para algo?

trait Container { 
    type A 
} 

trait AnotherContainer[B]{ 
    def x(b : B) : B 
} 

trait Mixed extends Container with AnotherContainer[Container#A] 

class Impl extends Mixed{ 
    def x(a : Container#A) = a 
} 

new Impl().x _ 

scala> new Impl().x _ 
res0: (Container#A) => Container#A = <function> 

Actualización:

class Baz { type T; } 

es en realidad una característica, pero no pude encontrar la motivación para ello: #1753.

Answer 1

Parece inofensivo si no sirve para nada. El tipo que x quiere no existe, por lo que no puede pasarlo al método. Si la inutilidad inofensiva debería ser un error en tiempo de compilación es una cuestión de gusto, supongo.

Si nos fijamos en lo que realmente hace x, decompila así:

public java.lang.Object x(java.lang.Object); 
    Code: 
    0: aload_1 
    1: areturn 

que es exactamente lo que el método de la identidad debe hacer (carga el argumento independientemente del tipo, devolverlo). Se puede escribir algo equivalente con mucho menos código:

trait AbstractType { type T } 
class Useless extends AbstractType { def identity(t: AbstractType#T) = t } 

Excepto nada tiene tipo AbstractType # T, lo que de nuevo tenemos la inutilidad.

A menos que me esté perdiendo algo.

Answer 2

En su ejemplo, el compilador agrega los límites de tipo predeterminados de >: Nothing <: Any. El segundo ejemplo a continuación muestra un caso en el que se puede usar un tipo abstracto (si no es útil).

scala> trait T { type A >: Nothing <: Any } 
defined trait T 

scala> 1: T#A 
<console>:6: error: type mismatch; 
found : Int(1) 
required: T#A 
     1: T#A 
    ^

scala> trait T { type A >: Int <: Int } 
defined trait T 

scala> 1: T#A       
res6: T#A = 1 

scala> "": T#A 
<console>:6: error: type mismatch; 
found : java.lang.String("") 
required: T#A 
     "": T#A 
    ^