为什么可以将递归 lambda 分配给 Scala 中的非惰性 val？

Question

在以下语句中，val f 被定义为引用自身的 lambda（它是递归的）：

val f: Int => Int = (a: Int) =>
    if (a > 10) 3 else f(a + 1) + 1 // just some simple function

我已经在 REPL 中尝试过了，它可以正确编译和执行。

根据规范，这似乎是非法前向引用的一个实例：

在一个语句序列s[1]...s[n]组成一个块，如果一个简单的 s[i] 中的名称指的是由s[j] 定义的实体，其中j >= i， 那么对于介于s[i]和s[j]之间的所有s[k]，

• s[k] 不能是变量定义。
• 如果s[k]是一个值定义，它必须是lazy。

该赋值是单个语句，因此它满足 j >= i 条件，并且它包含在两条规则适用的语句间隔中（在 s[i] 和 s[j] 之间并包括在内）。

但是，它似乎违反了第二条规则，因为f并不懒惰。

这是一个法律声明（在 Scala 2.9.2 中尝试过）？

Answer 1

您可能尝试在 REPL 中使用它，它将所有内容包装在一个对象定义中。这很重要，因为在 Scala（或更好：在 JVM 上）中，所有实例值都使用默认值进行初始化，对于所有 AnyRefs 和 0，null，0.0 或 false 对于 AnyVals .对于方法值，此默认初始化不会发生，因此在这种情况下您会收到一条错误消息：

scala> object x { val f: Int => Int = a => if (a > 10) 3 else f(a+1)+1 }
defined object x

scala> def x { val f: Int => Int = a => if (a > 10) 3 else f(a+1)+1 }
<console>:7: error: forward reference extends over definition of value f
       def x { val f: Int => Int = a => if (a > 10) 3 else f(a+1)+1 }
                                                           ^

这种行为甚至会导致奇怪的情况，因此应该小心递归实例值：

scala> val m: Int = m+1
m: Int = 1

scala> val s: String = s+" x"
s: String = null x