lazy val

You can see for yourself with the interpreter

scala> class A {
     |   lazy val foo = {
     |     println("Defining foo")
     |     (new scala.util.Random).nextInt
     |   }
     | }
defined class A

scala> val a = new A
a: A = A@2fba32e3

scala> println(a.foo)
Defining foo
-1824690572

scala> println(a.foo)
-1824690572

No clue why your breakpoints are getting triggered.

--j

On Tue, Jan 20, 2009 at 1:31 AM, Normen Mueller <normen.mueller@googlemail.com> wrote:

He,

I wonder if "lazy" values are re-computed every access call.  For example,

class A {
 lazy val foo = {
   // some complex computations
 }

val a = new A
println(a.foo)
println(a.foo)

I debugged the complex computation of "foo" and was surprised that my breakpoint within in the "foo" computation got called again in the second "println(a.foo)".

What am I missing here?

Cheers,
--
Normen Müller

On Jan 20, 2009, at 10:44 AM, Jorge Ortiz wrote:
> You can see for yourself with the interpreter
>
> scala> class A {
> | lazy val foo = {
> | println("Defining foo")
> | (new scala.util.Random).nextInt
> | }
> | }
> defined class A
>
> scala> val a = new A
> a: A = A@2fba32e3
>
> scala> println(a.foo)
> Defining foo
> -1824690572
>
> scala> println(a.foo)
> -1824690572
>
> No clue why your breakpoints are getting triggered.

Very good explanation! Thank you very much!

Cheers,
--
Normen Müller

Scala defines a singleton object, say Anonymous, which has foo as a member, and evaluates Anonymous.foo.
When using the lazy value foo, the definition of foo is not evaluated any more.

Note that, when defining the parameterlistless function foo, the definition of foo is not evaluated.
Scala defines a singleton object, say Anonymous, which has foo as a member.
When using the parameterlistless function foo, the definition of foo is evaluated.

--
  __~O
 -\ <,
(*)/ (*)

reality goes far beyond imagination

Luc Duponcheel wrote:
> FYI: try the following
>
> scala> lazy val foo = { println("evaluating") ; "foo" }
> evaluating
> foo: java.lang.String = foo
>
> scala> def bar = { println("evaluating") ; "bar" }
> bar: java.lang.String
>
> scala> foo
> res0: java.lang.String = foo
>
> scala> bar
> evaluating
> res1: java.lang.String = bar
>
> Note that, when /defining/ the lazy value foo, the definition of foo
> /is/ evaluated.
> Scala defines a singleton object, say Anonymous, which has foo as a
> member,/ and/ evaluates Anonymous.foo.
> When /using/ the lazy value foo, the definition of foo /is not/
> evaluated any more.

The lazy val foo is being shown as evaluated because the scala shell is using
toString on the value to print it, so it is being evaluated. I think a better
example is to show this:

scala> class Foo { lazy val foo = { println("evaluating") ; "foo" } }
defined class Foo

The foo isn't being evaluated when it is defined.

Blair

Normen Mueller wrote:
> He,
>
> I wonder if "lazy" values are re-computed every access call. For example,
>
> class A {
> lazy val foo = {
> // some complex computations
> }
>
> val a = new A
> println(a.foo)
> println(a.foo)
>
> I debugged the complex computation of "foo" and was surprised that my
> breakpoint within in the "foo" computation got called again in the
> second "println(a.foo)".
>
> What am I missing here?

Run javap on the class and you'll see some code there to check if it has been
evaluated so the debugger can still break on it.

Blair

On Jan 20, 2009, at 5:40 PM, Blair Zajac wrote:
> Normen Mueller wrote:
>> He,
>> I wonder if "lazy" values are re-computed every access call. For
>> example,
>> class A {
>> lazy val foo = {
>> // some complex computations
>> }
>> val a = new A
>> println(a.foo)
>> println(a.foo)
>> I debugged the complex computation of "foo" and was surprised that
>> my breakpoint within in the "foo" computation got called again in
>> the second "println(a.foo)".
>> What am I missing here?
>
> Run javap on the class and you'll see some code there to check if it
> has been evaluated so the debugger can still break on it.

That sounds reasonable! Thank you all for your help and confirmation
that I didn't understand "laziness" wrong ;-)

Cheers,
--
Normen Müller