能不能讲一下closure，正在看practical common lisp，就是理解不了这个概念

Question

书上的例子是
(let ((count 0)) #'(lambda () (setf count (1+ count))))

the reference to count inside the LAMBDA form should be legal according to the rules of lexical scoping. Yet the anonymous function containing the reference will be returned as the value of the LET form and can be invoked, via FUNCALL, by code that’s not in the scope of the LET. So what happens? As it turns out, when count is a lexical variable, it just works. The binding of count created when the flow of control entered the LET form will stick around for as long as needed, in this case for as long as someone holds onto a reference to the function object returned by the LET form. The anonymous function is called a closure because it “closes over” the binding created by the LET.
The key thing to understand about closures is that it’s the binding, not the value of the variable, that’s captured. Thus, a closure can not only access the value of the variables it closes over but can also assign new values that will persist between calls to the closure. For instance, you can capture the closure created by the previous expression in a global variable like this:

(defparameter *fn* (let ((count 0)) #'(lambda () (setf count (1+ count)))))

Then each time you invoke it, the value of count will increase by one.

CL-USER> (funcall *fn*)
1
CL-USER> (funcall *fn*)
2
CL-USER> (funcall *fn*)
3
基本上没看明白，而且红色的地方也有点奇怪

[ 本帖最后由 xdshting 于 2009-3-8 23:44 编辑 ]

Answer 1

原帖由 flw 于 2009-3-9 09:06 发表
1+ 是个函数名称呢？
还是仅仅只是 + 这个函数 curry 化的结果？

lisp 不支持自动 curry 化，1+ 是专门另做的一个函数。当然本质上可以看成 1+x 的 curry

在 emacs 中，对 1+ 的描述为：

1+ is a built-in function in `C source code'.

(1+ NUMBER)

Return NUMBER plus one.  NUMBER may be a number or a marker.
Markers are converted to integers.

Answer 2

谢谢了
再看ansi common lisp关于closure的介绍，又有一点不明白的地方
书上的例子
( let ((counter 0))
    (defun reset ()
       (setf counter 0))
    (defun stamp ()
       (setf counter (+ counter 1))))

CL-USER> ( l i s t (stamp) (stamp) ( reset ) (stamp))
          ( 1 2 0 1)

list是怎么看到stamp和reset函数的？这两个函数在let内部定义的阿

[ 本帖最后由 xdshting 于 2009-3-9 09:38 编辑 ]

Answer 3

1+ 是个函数名称呢？
还是仅仅只是 + 这个函数 curry 化的结果？

Answer 4

原帖由 xdshting 于 2009-3-9 00:50 发表
谢谢，现在明白一些了

看到您用
（funcall '+ 3 4）
我用
（funcall #'+ 3 4）

可以得到相同的结果，我觉得你用的形式不对阿，为什么能执行？

参考这个连接，http://www.lispworks.com/documen ... c/Body/f_funcal.htm

Syntax:

funcall function &rest args => result*

......

funcall applies function to args. If function is a symbol, it is coerced to a function as if by finding its functional value in the global environment.

所以两种形式都是可以的。

Answer 5

谢谢，现在明白一些了

看到您用
（funcall '+ 3 4）
我用
（funcall #'+ 3 4）

可以得到相同的结果，我觉得你用的形式不对阿，为什么能执行？

Answer 6

1、

2. 每次运行(funcall (let ((count 0)) #'(lambda () (setf count (1+ count))))) 的值都是1

复制代码
因为每次运行都得到一个新的匿名函数，它也包有一个新的环境，在该环境中，count 值为 0。

2、

2. (defparameter *fn* (let ((count 0)) #'(lambda () (setf count (1+ count)))))

复制代码
以后通过 *fn* 去调用，let 只执行了一次，只有一个与 *fn* 关联的匿名函数(相应的私有空间)。

看看下面的演示

2. [1]> (defparameter f (let ((count 0)) #'(lambda () (setf count (1+ count)))))F
3. [2]> (defparameter g (let ((count 0)) #'(lambda () (setf count (1+ count)))))
4. G
5. [3]> (funcall f)
6. 1
7. [4]> (funcall f)
8. 2
9. [5]> (funcall f)
10. 3
11. [6]> (funcall g)
12. 1
13. [7]>

复制代码

f, g 的私有空间是不同的。直接 funcall let 的结果相当于每次都生成一个新函数，所以值也都是 1 了。

3、1+ 是个函数名字，这个函数接受一个参数；+ 是另外一个函数，接受 0 个或多个参数.

2. > (funcall '1+ 2)
3. 3
4. > (funcall '+ 1 2)
5. 3
6. > (funcall '+ 2 1)
7. 3

复制代码

（1＋ count）与（＋ 1 count）的结果是一样的，但调用的是不同的函数。

Answer 7

每次运行(funcall (let ((count 0)) #'(lambda () (setf count (1+ count))))) 的值都是1
而
(defparameter *fn* (let ((count 0)) #'(lambda () (setf count (1+ count)))))

Then each time you invoke it, the value of count will increase by one.

CL-USER> (funcall *fn*)
1
CL-USER> (funcall *fn*)
2
CL-USER> (funcall *fn*)
3
这怎么解释,红色部分不就是说用defparameter代替后面的（let...）吗？
另外
（1＋ count）与（＋ 1 count）有区别吗？

谢谢

[ 本帖最后由 xdshting 于 2009-3-9 00:23 编辑 ]

Answer 8

scheme 是第一个引入静态作用域的 lisp，后来 Guy Steel 跑去开发 common lisp，把这个也加进去了。

有一些 lisp 是动态作用域的，比如 elisp. 如果在 emacs 中执行

2. (setq *fn* (let ((count 0)) #'(lambda () (setq count (1+ count)))))
5. (funcall *fn*)

复制代码

就会出错，因为: Debugger entered--Lisp error: (void-variable count)

显然 *fn* 找不到 count 了。如果在函数外面定义一个 count，值为 100

2. (setq *fn* (let ((count 0)) #'(lambda () (setq count (1+ count)))))
4. (setq count 100)
6. (funcall *fn*)

复制代码

则 funcall 的结果为 101，显然跟 let 里头的 count 是无关的。

[ 本帖最后由 win_hate 于 2009-3-9 00:19 编辑 ]

Answer 9

1. let 为 count 绑定了一个值 0，返回的匿名函数可以引用，修改它。这称为 static scope (lexical)，类似于 c 语言中的静态变量。粗略地讲，闭包包住了一个私有环境。

2. 返回的匿名函数若与变量 *fn* 绑定，则可以通过 *fn* 来调用，访问并修改匿名函数的“私有环境”。

3. lisp 支持自动垃圾回收，当匿名函数不再被使用时，资源会被回收。(... will stick around for as long as needed ...)

4. 1+ 是个函数，对参数执行加 1 操作.