为什么 (c1) 返回 1, 2, 3 等.. 而不是 #<procedure:...make_counter.rkt:8:5>？

Question

这是来自环境模型部分的 SICP 课程：

(define make-counter 
   (lambda (n)    
     (lambda () (set! n (+ n 1))
       n)))    

下面，解释器说(make-counter 0)是一个过程：

> (make-counter 0)
#<procedure:...make_counter.rkt:8:5>

下面，我将c1定义为(make-counter 0)。

(define c1 (make-counter 0)

下面是我对(c1) 返回计数器值而不是"procedure" 的原因感到困惑的地方。

>(c1)
1
> (c1)
2
> (c1)
3

我的思考过程是如果(c1)指向一个过程(make-counter)，那么(c1)应该返回"procedure:...make_counter.rkt:8:5"。

因为程序 -> 程序。

我知道应该发生什么，我只是在概念上对如何以及为什么感到困惑。

Answer 1

你的问题是什么？您是否怀疑它是否像名字所暗示的那样工作，或者您不明白它是如何工作的？

第一个30秒可以测试，第二个我来回答：

make-counter 是一个接受一个参数的过程。现在再看一下代码：它返回了什么？一个有 0 个参数的过程。

所以执行(c1) 将返回从1 向上的数字（如果从0 开始）。

为了完整性：

Gambit v4.8.1

> (define make-counter 
   (lambda (n)    
     (lambda () (set! n (+ n 1))
       n)))    
> (define c1 (make-counter 0))
> (c1)
1
> (c1)
2
> (c1)
3
> 

问题编辑后添加：

c1 是过程，但(c1) 是过程应用程序，在另一个编程世界中你会称之为“调用过程”。

> c1
#<procedure #2 c1>
> (c1)
1

顺便说一句，一段很好的函数式代码，如果你理解了这一点，你会以不同的方式看待编程。

更多问题通过评论：

现在，它的 (make-counter 0)。手工操作，看不懂 为什么没有返回 n。

关于c1 和(c1)，我们给你的答案是一样的：

make-counter 返回lambda ()，只有调用 lambda 时才返回 n。函数（在方案中：过程，lambdas）是可以传递的值，函数式编程原则。您必须调用它们（正确术语：应用）才能获取过程结果。

现在告诉我：如何调用方案中的过程？

更多修改：

好的，我们通过用括号括起来来调用方案中的过程。

现在告诉我：(c1) 的替换步骤是什么？

Answer 2

我的思考过程是，如果 (c1) 指向一个过程 (make-counter)，那么 (c1) 应该返回“procedure:...make_counter.rkt:8:5”。

这是错误的。

这里发生的事情是c1“指向一个过程”，正如你所说，（实际上它是一个绑定到一个过程的名称）。

您应该记住，在 Scheme 中，(f e1 e2 ... en) 形式是调用过程f 的方式，将表达式e1 e2 ... en 的值传递给它。

所以，(c1) 与c1 完全不同：它是一种调用过程c1（没有参数）的方式。每次解释器/编译器评估(c1) 时，它都会调用过程，增加值并返回它。

Answer 3

你有

(define make-counter 
   (lambda (n)    
     (lambda () (set! n (+ n 1))
       n)))  

所以评估make-counter

返回

   (lambda (n)    
     (lambda () (set! n (+ n 1))
       n))

并评估(make-counter 0) 只是用它的值替换该调用中的make-counter，然后继续

( (lambda (n)    
     (lambda () (set! n (+ n 1))
       n))
   0 )
=>
(let ((n 0))    
     (lambda () (set! n (+ n 1)) 
       n))

这样就创建并返回了闭包对象，

=>
(closure {environment1: ((n 0))}     ; its own binding for `n`
     (lambda () (set! n (+ n 1)) 
       n))

所以在(define c1 (make-counter 0)) 之后这个闭包就是c1 的值。

评估c1 返回其值，即上述过程（闭包）。它的打印表示是依赖于实现的（例如显示#<procedure> 或类似的东西）。

评估(c1)调用这个过程，

(c1)
=>
( (closure {environment1: ((n 0))}     ; its own binding for `n`
     (lambda () (set! n (+ n 1)) 
       n)) )
=>
(under {environment1: ((n 0))}
  (  (lambda () (set! n (+ n 1)) 
       n)) )

不带任何参数调用((lambda () ...) ) 只是评估其主体而不创建任何新环境，因为参数列表为空且没有参数：

=>
(under {environment1: ((n 0))}
    (set! n (+ n 1))             ; perform this first
    n )
=>
(under {environment1: ((n 1))}   ; <--- altered binding for `n`!
    n )                          ; now evaluate this and return its value
=>
1

它离开了改变的 environment1。当再次调用该过程（闭包）时，(c1)，其环境现在将包含((n 1))，因此将更改为((n 2))，等等。