捕捉值

Question

如果我們賦值給一個變量：

(setf i 10) 

，然後創建一個lambda函數關閉了它：

(setf f #'(lambda() i)) 

我們的行爲

(incf i) ;=> 11 
(funcall f) ;=> 11 

相反，我想函數總是返回值i在函數wa創建。例如：

(incf i) ;=> 11 
(funcall f) ;=> 10 

本質上，我想將i變成lambda體內的字面值。這在Common Lisp中可以做到嗎？原因是我在一個循環內部創建了多個lambda表達式，並且需要在它們的body中使用索引，而不需要在創建之後改變它們。

Answer 1

只需綁定一個變量與值的副本。例如：

(let ((i i)) 
    (lambda() i)) 

這實際上是用的迭代結構的一項重要技術，因爲像

(loop for i from 1 to 10 
    collecting (lambda() i)) 

可以在相同的變量返回10封，所以寫有必要：

(loop for i from 1 to 10 
    collecting (let ((i i)) (lambda() i))) 

如果你真的只需要一個返回值的函數，你也可以使用constantly（但我期望真實的用例更復雜）：

(loop for i from 1 to 10 
    collecting (constantly i)) 

迭代形式的歧義實際上是由標準指定的，在某些情況下。例如，對於dotimes，dolist

這是實現相關dotimes是否建立VAR的一個新的綁定在每次迭代或者是否建立之初的VAR綁定一次，然後分配給它的任何後續的迭代。

更原始do，然而，實際上規定了有一組綁定的形式，和（強調），它們在每次迭代更新：

在每次的開始除第一次迭代外，變量更新如下。＆hellip;

這種不明確性給實現帶來了更多的靈活性。

(defmacro dolist ((var list &optional result) &body body) 
    `(progn (mapcar #'(lambda (,var) 
         ,@(ex:body-declarations body) 
         (tagbody 
         ,@(ex:body-tags-and-statements body))) 
        ,list) 
      (let ((,var nil)) 
      ,result))) 

(defmacro dolist ((var list &optional result) &body body) 
    (let ((l (gensym (string '#:list-)))) 
    `(do* ((,l ,list (rest ,l)) 
      (,var (first ,l) (first ,l))) 
      ((endp ,l) ,result) 
     ,@body))) 

Answer 2

這並不完全清楚你想要什麼。如果你想創建一個範圍內存在共享變量i，你可以用let做到這一點。

CL-USER> (let ((i 10)) 
     (defun show-i() i) 
     (defun inc-i() (incf i)) 
     (defun dec-i() (decf i))) 
DEC-I 
CL-USER> (show-i) 
10 
CL-USER> (inc-i) 
11 
CL-USER> (show-i) 
11 
CL-USER> (dec-i) 
10 
CL-USER> (dec-i) 
9 
CL-USER> (show-i) 
9 
CL-USER> 

如果您正在尋找使用動態範圍變量，則可以使用直線型defvar。

CL-USER> (defvar *a* 10) 
*A* 
CL-USER> (defun show-a() *a*) 
SHOW-A 
CL-USER> (show-a) 
10 
CL-USER> *a* 
10 
CL-USER> (incf *a*) 
11 
CL-USER> (incf *a*) 
12 
CL-USER> (show-a) 
12 
CL-USER> 

Answer 3

萬一上述兩個答案不透明度不夠的：

(defparameter *i* 10) 
;;Before you modify *i* 
(defvar f (let ((i *i*)) 
       #'(lambda() i))) 
;;Now f will always return 10 
(funcall f) => 10 
(incf *i*) => 11 
(funcall f) => 10