कैद मूल्य

Question

हम एक चर को कोई मान निर्दिष्ट हैं:

(setf i 10) 

और फिर एक इस पर एक लैम्ब्डा समारोह समापन बनाएँ:

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

हम व्यवहार

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

इसके बजाय, मैं फ़ंक्शन वा को उस समय i के मान को हमेशा वापस करना चाहता हूं एस बनाया गया है। उदा .:

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

अनिवार्य रूप से मैं लैम्ब्डा शरीर के अंदर एक शाब्दिक में i चालू करने के लिए करना चाहते हैं। क्या आम लिस्प में ऐसा करना संभव है? इसका कारण यह है कि मैं एक लूप के अंदर एक से अधिक लैम्ब्डा बना रहा हूं, और उनके शरीर में इंडेक्स का उपयोग करने की आवश्यकता है, बिना सृजन के अलग-अलग।

Answer 1

बस मूल्य की प्रति के साथ एक चर को बांधें। उदाहरण के लिए:

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

यह वास्तव में, यात्रा निर्माणों के साथ एक महत्वपूर्ण तकनीक है क्योंकि कुछ

तरह

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

एक ही चर से अधिक दस बंदी वापस आ सकते हैं, तो यह लिखने के लिए आवश्यक हो जाता है:

(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 प्रत्येक यात्रा पर वार करने का एक नया बंधन स्थापित करता है कि क्या है या यह है कि क्या शुरुआत में वर के लिए एक बाध्यकारी एक बार स्थापित करता है और फिर बाद में किसी भी पुनरावृत्तियों पर यह प्रदान करती है।

अधिक आदिम 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> 

आप गतिशील scoped चर का उपयोग करने के लिए देख रहे हैं, तो आप सीधे-अप 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