Lazy vals and implicit parameters in Scala
implicit, lazy-evaluation, parameters, scala
Solution
That is because there is no other `implicit Bar`, when the compiler compiles the Foo class. The decompiled code in Java look like this:
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$;
}
}
The `lazy val` is just a method that checks if the variable is already set and either returns it, or sets it and then returns it. So your mixin is not taken into account at all. If you want that, you have to take care of the initialization yourself.
Problem
I have been trying to get a grasp on how implicit parameters work in Scala. As far as I can tell the implicit parameter resolution goes something like this: - Explicitly passing an object to the method. - implicit definitons defined in scope. - Companion object of the class used as a implicit parameter However, when I started playing around with this in conjunction lazy vals I got a bit of a supprise. It seems that lazy vals only ever use the last resolution rules. Here is some sample code to illustrate: ``` 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` gives the following output: ``` 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' ... ``` Why does the compiler not catch that there is a implict Bar mixed in when calling mixedInList in Case 2. In Case 3 it also misses the locally defined implicit Bar when accessing the list. Are there any ways to use implicit parameters with lazy vals that does not use the implicit defined in the companion object?