Lazy vals y los parámetros implícitos en Scala

Question

He estado tratando de entender cómo funcionan los parámetros implícitos en Scala. Por lo que puedo decir, la resolución de los parámetros implícitos es algo como esto:

1. Pasar explícitamente un objeto al método.
2. definiciones definidas definidas en el alcance.
3. Companion objeto de la clase utilizada como un parámetro implícito

Sin embargo, cuando empecé a jugar con esto en conjunto Vals perezosos me dieron un poco de un supprise. Parece que los vagos perezosos solo usan las últimas reglas de resolución. Aquí hay un código de ejemplo para ilustrar:

class Bar(val name:String) 
object Bar { implicit def bar = new Bar("some default bar") } 

class Foo { 
    lazy val list = initialize 
    def initialize(implicit f:Bar) = { 
    println("initialize called with Bar: '" + f.name + "' ...") 
    List[Int]() 
    } 
} 

trait NonDefaultBar extends Foo { 
    implicit def f = new Bar("mixed in implicit bar") 
    def mixedInInit = initialize 
    lazy val mixedInList = list 
} 

object Test { 
    def test = { 
     println("Case 1: with implicitp parameter from companion object") 
     val foo1 = new Foo 
     foo1.list 
     foo1.initialize 

     println("Case 2: with mixedin implicit parameter overriding the default one...") 
     val foo2 = new Foo with NonDefaultBar 
     foo2.mixedInList 

     val foo3 = new Foo with NonDefaultBar 
     foo3.mixedInInit 

     println("Case 3: with local implicit parameter overriding the default one...") 
     implicit def nonDefaultBar = new Bar("locally scoped implicit bar") 
     val foo4 = new Foo 
     foo4.list 
     foo4.initialize 
    } 
} 

Calling Test.test da el siguiente resultado:

Case 1: with implicitp parameter from companion object 
initialize called with Bar: 'some default bar' ... 
initialize called with Bar: 'some default bar' ... 
Case 2: with mixedin implicit parameter overriding the default one... 
initialize called with Bar: 'some default bar' ... 
initialize called with Bar: 'mixed in implicit bar'... 
Case 3: with local implicit parameter overriding the default one... 
initialize called with Bar: 'some default bar' ... 
initialize called with Bar: 'locally scoped implicit bar' ... 

¿Por qué el compilador no captura que hay un bar implict mezclado en al llamar mixedInList en el caso 2. En el caso 3, también omite la barra implícita definida localmente al acceder a la lista.

¿Hay alguna forma de utilizar parámetros implícitos con vals perezosos que no utilizan el implícito definido en el objeto complementario?

Answer 1

Eso es porque no hay otro implicit Bar, cuando el compilador compila la clase Foo. El código descompilada en Java aspecto:

public class Foo 
    implements ScalaObject 
{ 
    private List<Object> list; 
    public volatile int bitmap$0; 

    public List<Object> list() 
    { 
    if (
     (this.bitmap$0 & 0x1) == 0); 
    synchronized (this) 
    { 
     if (
     (this.bitmap$0 & 0x1) == 0) { 
     this.list = initialize(Bar..MODULE$.bar()); this.bitmap$0 |= 1; } return this.list; 
    } 
    } 
    public List<Object> initialize(Bar f) { Predef..MODULE$.println(new StringBuilder().append("initialize called with Bar: '").append(f.name()).append("' ...").toString()); 
    return Nil..MODULE$; 
    } 
} 

la lazy val es sólo un método que comprueba si la variable ya está establecido y, o bien lo devuelve, o lo pone él y luego lo devuelve. Por lo tanto, tu mixin no se tiene en cuenta en absoluto. Si lo desea, debe encargarse usted mismo de la inicialización.

Answer 2

Aunque scala no es compatible con lazy vals con parámetros implícitos, puede definirlo usted mismo mediante las opciones. Por lo tanto, una solución es reemplazar:

lazy val list = initialize 

por

private var _list: Option[List[Int]] = None 
def list(implicit f: Bar) = 
    _list.getOrElse{ 
    _list = Some(initialize) 
    _list.get 
    } 

Entonces el correr Test.test muestra el resultado esperado:

Case 1: with implicitp parameter from companion object 
initialize called with Bar: 'some default bar' ... 
initialize called with Bar: 'some default bar' ... 
Case 2: with mixedin implicit parameter overriding the default one... 
initialize called with Bar: 'mixed in implicit bar' ... 
initialize called with Bar: 'mixed in implicit bar' ... 
Case 3: with local implicit parameter overriding the default one... 
initialize called with Bar: 'locally scoped implicit bar' ... 
initialize called with Bar: 'locally scoped implicit bar' ... 

Tenga en cuenta que si tiene que mutable options, podría reemplazar a su perezoso val con solo dos líneas para obtener el mismo resultado.

private val _list: MutableOpt[List[Int]] = MutableOpt.from(None) 
def list(implicit f: Bar) = _list.getOrSet(initialize) 

Personalmente, espero que algún día Scala escribamos esto utilizando una línea:

lazy val list(implicit f: Bar) = initialize 

que sería perfectamente significativa: En cualquier momento que desee acceder al valor de la lista de variables, necesita una barra en el alcance, aunque solo el primer cálculo importará.