Scala中lazy vals的范围规则是什么？

Question

I was reading the sbt documentation, and I came across this example in the section on multi project builds:

import sbt._
import Keys._

object HelloBuild extends Build {
    lazy val root = Project(id = "hello",
                            base = file(".")) aggregate(foo, bar)

    lazy val foo = Project(id = "hello-foo",
                           base = file("foo"))

    lazy val bar = Project(id = "hello-bar",
                           base = file("bar"))
}

I am wondering how it is possible to reference the values foo and bar before they have been declared? I figure it has something to do with the lazy keyword, but from my reading, I thought the lazy keyword only delayed initialization? It seems here that the values are somehow in scope even before declaration, never mind initialization...

Hopefully someone is able to explain what is going on here!

Answer 1

See chapter 4 of the Scala language specification :

The scope of a name introduced by a declaration or definition is the whole statement sequence containing the binding. However, there is a restriction on forward references in blocks: In a statement sequence s ₁ ... s _n making up a block, if a simple name in s _i refers to an entity defined by s _j where j ≥ i, then for all s _k between and including s _i and s _j ,

• s _k cannot be a variable definition.
• If s _k is a value definition, it must be lazy.

In other words: you can have forward references on lazy vals, but only if there are no vars or non-lazy vals between them. This is kind of intuitive if you consider that a lazy val works more like a method than like a variable, and walk though two quick examples on the REPL:

scala> object o { val a = b; lazy val c = 6; lazy val b = c }
defined module o

scala> o.a
res1: Int = 6

In this first example, Scala evaluates a by invoking b , which in turn invokes c , which evaluates to 6 . But in the next example, when c is not lazy ...

scala> object o { val a = b; val c = 6; lazy val b = c }
defined module o

scala> o.a
res2: Int = 0

When Scala evaluates a , it invokes b , which returns the current value of c (which at that time is 0 , the JVM's default value for integers, because c is not yet initialized). Then c is initialized afterward, but by then it is too late.

See also: How are lazy val class variables implemented in Scala 2.10?

Answer 2

Just like in Java, a class instance variable (or scala val) is "in scope" within any part of the containing class/object, regardless of where it is declared.

That said, it will not be "initialized" for any code referencing it and running prior to it's point of declaration. A lazy-val's code doesn't run at the point it's declared, so that's safe.