Scala lazy val interpretation - scala

Question

I am learning Scala basics. I just came across the lazy val concept. I have following code snippets which work without errors/warnings
Case 1
lazy val a = 10 + b
lazy val b = 5
println(a)
Case 2
lazy val a = 10 + b
val b = 5
println(a)
Case 3
val a = 10 + b
lazy val b = 5
println(a)
I understand how case 1 & 2 work. But I don't understand how the code in case 3 is working without error/warning. How is Scala able to evaluate the value of a when b is not yet defined?
EDIT
I am not running this code in Scala REPL. I have saved the code in case 3 in file called lazyVal.scala. I am executing it using scala lazyVal.scala. I think scala interprets the code in the file.
If I change the code in lazyVal.scala to
val a = 10 + b
val b = 5
println(a)
And execute it using scala lazyVal.scala I do get warning
/Users/varun.risbud/scalaRepo/src/Chapter1/lazyVal.scala:1: warning: Reference to uninitialized value b
val a = 10 + b
^
one warning found
10
Also If I change the code to create object and extend App it works
object lazyVal extends App {
val a = 10 + b
lazy val b = 5
println(a)
}
➜ Chapter1 scalac lazyVal.scala
➜ Chapter1 scala lazyVal
15
My scala version is 2.12.1 if that makes any difference.

Answer 1

Statements in a constructor execute in textual order, which is why you get a warning when the initialization of a refers to the uninitialized b. It's a common error to compose a class in a way that you don't even get the warning. (There's a FAQ tutorial about that.)
The same text is forbidden in a local sequence of statements:
scala> :pa
// Entering paste mode (ctrl-D to finish)
locally {
val a = 10 + b
lazy val b = 5
println(a)
}
// Exiting paste mode, now interpreting.
<console>:13: error: forward reference extends over definition of value a
val a = 10 + b
^
As members of a class or object, the lazy member is evaluated "on demand", when a is evaluated during construction.
scala> :pa
// Entering paste mode (ctrl-D to finish)
object X {
val a = 10 + b
lazy val b = 5
println(a)
}
// Exiting paste mode, now interpreting.
defined object X
scala> X
15
res1: X.type = X$#6a9344f5
The script runner packages your lines of code this way:
object X {
def main(args: Array[String]): Unit =
new AnyRef {
val a = 10 + b
lazy val b = 5
println(a)
}
}
If you give it an object with a main or that extends App, it won't wrap the code but just use it directly.
There are subtle differences between the three formulations. For example, the constructor of a top-level object is run as a static initializer; but an App is special-cased to run initializer code as main. (They're getting rid of App because it's confusing.)