语法 – 为什么Scala自动应用thunk,有时？

在 ShadowofCatron的 Scala Tutorial 3 video的2:40之后，它指出，在 thunk之后的括号是可选的。 “Buh？”说我的功能编程大脑，因为一个函数的价值和它应用时的评估值是完全不同的东西。

所以我写下来试试这个。我的思想过程在评论中描述。

object Main {

    var counter: Int = 10
    def f(): Int = { counter = counter + 1; counter }

    def runThunk(t: () => Int): Int = { t() }

    def main(args: Array[String]): Unit = {
        val a = f()     // I expect this to mean "apply f to no args"
        println(a)      // and apparently it does

        val b = f       // I expect this to mean "the value f",a function value
        println(b)      // but it's the value it evaluates to when applied to no args
        println(b)      // and the application happens immediately,not in the call

        runThunk(b)     // This is an error: it's not println doing something funny
        runThunk(f)     // Not an error: seems to be val doing something funny
    }

}

要清楚的问题，这个Scheme程序(和控制台转储后面)显示了我期望的Scala程序。

(define counter (list 10))
(define f (lambda ()
            (set-car! counter (+ (car counter) 1))
            (car counter)))

(define runThunk (lambda (t) (t)))

(define main (lambda args
               (let ((a (f))
                     (b f))
                 (display a) (newline)
                 (display b) (newline)
                 (display b) (newline)
                 (runThunk b)
                 (runThunk f))))

> (main)
11
#<procedure:f>
#<procedure:f>
13

在访问这个网站询问这个问题后，我遇到了this answer告诉我如何修复上面的Scala程序：

val b = f _     // Hey Scala,I mean f,not f()

但是下划线“提示”只是有时需要。当我调用runThunk(f)，不需要提示。但是当我’别名’到b与一个val然后应用它，它不工作：应用程序发生在val;和甚至惰性val工作这种方式，所以它不是评价导致这种行为的点。

这一切都留给我的问题：

为什么Scala有时会在评估它们时自动应用thunk？

是否，我猜想，类型推理？如果是这样，一个类型系统不应该停留在语言的语义之外？

这是一个好主意吗？ Scala程序员应用thunk，而不是参考他们的值，更多的是，使括号是可选的更好的整体？

使用Scala 2.8.0RC3编写的示例，R5RS中的DrScheme 4.0.1。

def f(): Int = { counter = counter + 1; counter }

val b = f _     // Hey Scala,not f()

val b = () => f()