comodines genéricos en las declaraciones de variables en Scala

Question

En Java podría hacer esto:

class MyClass { 
    private List<? extends MyInterface> list; 

    public void setList(List<MyImpl> l) { list = l; } 
} 

... suponiendo que (MyImpl implements MyInterface) por supuesto.

¿Cuál es el analógico para esto en Scala, cuando se utiliza un Buffer?

import java.lang.reflect._ 
import scala.collection.mutable._ 

class ScalaClass { 
    val list:Buffer[MyInterface] = null 

    def setList(l: Buffer[MyImpl]) = { 
    list = l 
    } 
} 

Este (por supuesto) no se compila - pero ¿cómo puedo declarar la variable list de tal manera que lo hace?

EDIT; Estoy agregando un poco más. La diferencia obviamente tiene que ver con el hecho de que en Java, los genéricos son nunca covariantes en T, mientras que en Scala pueden ser covariantes o no. Por ejemplo, la clase Scala List es covariante en T (y necesariamente inmutable). Por lo tanto el siguiente compilará:

class ScalaClass { 
    val list:List[MyInterface] = null 

    def setList(l: List[MyImpl]) = { 
    list = l 
    } 
} 

Todavía estoy luchando un poco con el error del compilador:

Covariant type T occurs in contravariant position in ...

Por ejemplo; este error de compilación se produce en la declaración de clase:

class Wibble[+T] { 
    var some: T = _ //COMPILER ERROR HERE! 
} 

voy a hacer una pregunta separada ...

Answer 1

El análogo directo a

import java.util.List; 
List<? extends MyInterface> list; 

es

import java.util.List 
var list : List[_ <: MyInterface] = _; 

Lo mismo pasa con Tampón

Para responder a un comentario que hizo earler, en parámetros de tipo Java son siempre invariable, no covariante.

Answer 2

no estoy seguro en absoluto entiendo su pregunta (probablemente no es suficiente café en mi parte) pero parece que estás preguntando por generic classes. Si no es así, deje un comentario o agregue más información a su pregunta & Volveré más tarde & para editar mi respuesta.