Что делает ленивый вал?

Эта функция помогает не только откладывать дорогостоящие вычисления, но также полезно создавать взаимно зависимые или циклические структуры. Например. это приводит к переполнению стека:

trait Foo { val foo: Foo }
case class Fee extends Foo { val foo = Faa() }
case class Faa extends Foo { val foo = Fee() }

println(Fee().foo)
//StackOverflowException

Но с ленивыми счетами он отлично работает

trait Foo { val foo: Foo }
case class Fee extends Foo { lazy val foo = Faa() }
case class Faa extends Foo { lazy val foo = Fee() }

println(Fee().foo)
//Faa()

Я понимаю, что ответ дан, но я написал простой пример, чтобы понять его для начинающих, таких как я:

var x = { println("x"); 15 }
lazy val y = { println("y"); x+1 }
println("-----")
x = 17
println("y is: " + y)

Вывод кода выше:

x
-----
y
y is: 18

Как можно видеть, x печатается, когда он инициализируется, но y не печатается, когда он инициализируется таким же образом (я принял x как var намеренно здесь - объяснить, когда y инициализируется). Далее, когда вызывается y, он инициализируется, а также значение последнего "x" принимается во внимание, но не является старым.

Надеюсь, что это поможет.

Ленивый val наиболее легко понимается как " memoized (no-arg) def".

Как def, lazy val не оценивается до его вызова. Но результат сохраняется, так что последующие вызовы возвращают сохраненное значение. Мембранный результат занимает место в вашей структуре данных, например, val.

Как отмечали другие, варианты использования для ленивого val - отложить дорогостоящие вычисления до тех пор, пока они не понадобятся, и сохранить их результаты, а также решить определенные круговые зависимости между значениями.

На самом деле ленивые валы реализованы более или менее как memoized defs. Вы можете прочитать о деталях их реализации здесь:

http://docs.scala-lang.org/sips/pending/improved-lazy-val-initialization.html

Также lazy полезен без циклических зависимостей, как в следующем коде:

abstract class X {
  val x: String
  println ("x is "+x.length)
}

object Y extends X { val x = "Hello" }
Y

Доступ к Y теперь приведет к исключению нулевого указателя, потому что x еще не инициализирован. Однако следующее работает отлично:

abstract class X {
  val x: String
  println ("x is "+x.length)
}

object Y extends X { lazy val x = "Hello" }
Y

ИЗМЕНИТЬ: будет также работать следующее:

object Y extends { val x = "Hello" } with X 

Это называется "ранним инициализатором". Подробнее см. этот вопрос SO.

scala> lazy val lazyEight = {
     |   println("I am lazy !")
     |   8
     | }
lazyEight: Int = <lazy>

scala> lazyEight
I am lazy !
res1: Int = 8

• Все vals инициализируются при построении объекта
• Использовать ленивое ключевое слово для отсрочки инициализации до первого использования
• Внимание: Lazy vals не являются окончательными и поэтому могут показывать недостатки производительности.

Демонстрация lazy исполнения при определении и исполнении при доступе: (с использованием оболочки 2.12.7 scala)

// compiler says this is ok when it is lazy
scala> lazy val t: Int = t 
t: Int = <lazy>
//however when executed, t recursively calls itself, and causes a StackOverflowError
scala> t             
java.lang.StackOverflowError
...

// when the t is initialized to itself un-lazily, the compiler warns you of the recursive call
scala> val t: Int = t
<console>:12: warning: value t does nothing other than call itself recursively
   val t: Int = t