मैं अगर आप इसे विहित सूत्रीकरण कहेंगे नहीं जानते हैं और Emacs में flet तुतलाना

Question

, लेकिन एक स्थानीय समारोह मैं जीएनयू मैनुअल ने सलाह दी हूँ 'flet' का उपयोग करने के लिए बाध्य करने के लिए:

(defun adder-with-flet (x) 
    (flet ((f (x) (+ x 3))) 
    (f x)) 
) 

हालांकि , दुर्घटना से मैंने कोशिश की (एक बिट के लिए योजना में खेला जाने के बाद) निम्नलिखित अभिव्यक्ति, जहां मैं 'लेट' का उपयोग करके एक चरम पर एक लैम्ब्डा अभिव्यक्ति बांधता हूं, और यह भी काम करता है अगर मैं फ़ंक्शन को मैपकार *:

(defun adder-with-let (x) 
    (let ((f (lambda (x) (+ x 3)))) 
    (car (mapcar* f (list x)))) 
) 

पर फ़ंक्शन पास करता है

और दोनों कार्य कार्य करते हैं:

(adder-with-flet 3) ==> 6 
(adder-with-let 3) ==> 6 

दूसरा काम क्यों करता है? मुझे कोई दस्तावेज नहीं मिल रहा है जहां प्रतीकों के कार्यों को बांधने के लिए 'चलो' का उपयोग किया जा सकता है।

Answer 1

योजना के विपरीत, Emacs Lisp 2-lisp है, जिसका अर्थ है कि प्रत्येक प्रतीक में दो अलग-अलग बाइंडिंग होते हैं: मान बाध्यकारी और फ़ंक्शन बाइंडिंग। फ़ंक्शन कॉल (a b c d) में, पहला प्रतीक (a) फ़ंक्शन बाध्यकारी का उपयोग करके देखा जाता है, शेष (b c d) मान बाध्यकारी का उपयोग करके देखा जाता है। विशेष फॉर्म let एक नया (स्थानीय) मान बाध्यकारी बनाता है, flet एक नया फ़ंक्शन बाध्यकारी बनाता है।

ध्यान दें कि मूल्य या समारोह बंधन देखने के लिए इस्तेमाल किया है या नहीं, (a b c d) समारोह कॉल में स्थिति पर निर्भर करता है प्रकार देखा-अप मूल्य का पर नहीं। विशेष रूप से, एक मूल्य बाध्यकारी कार्य करने के लिए हल कर सकते हैं।

अपने पहले उदाहरण में, आप में कार्य-बाँध f (flet के माध्यम से), और फिर एक समारोह देखने कार्य करें:

(f ...) 

अपने दूसरे उदाहरण में, आप मूल्य-बाँध f एक समारोह के लिए (let के माध्यम से)

(... f ...) 

दोनों काम है क्योंकि आप बंधन और प्रत्येक मामले में देखने का एक ही तरह का उपयोग करें:, और फिर एक मूल्य देखने का उपयोग करें।

http://en.wikipedia.org/wiki/Common_Lisp#Comparison_with_other_Lisps

Answer 2

मैं Emacs की एक त्वरित खोज तुतलाना मैनुअल किया था और के बाद से है कि cl का एक हिस्सा है 'flet के लिए किसी भी संदर्भ है, जो बहुत आश्चर्य की बात नहीं है नहीं पा सके - common-lisp package।

let स्थानीय बाध्यकारी भी करेगा, लेकिन यह उस प्रतीक के लिए "function cell" से जुड़ा नहीं होगा।

यह यानी काम करता है:

(let ((myf (lambda (x) (list x x)))) 
    (eval (list myf 3))) 

लेकिन

(let ((myf (lambda (x) (list x x)))) 
    (myf 3)) 

त्रुटि के साथ विफल: "लिस्प त्रुटि: (शून्य-समारोह myf)"

दूसरी ओर flet, करता है फ़ंक्शन सेल के लिए बाध्यकारी करें, इसलिए यह काम करता है:

(flet ((myf (x) (list x x))) 
    (myf 3)) 

ध्यान दें कि flet आपको myf प्रतीक का उपयोग करने की अनुमति देता है, जबकि let नहीं है - आपको "मूल्य सेल" से कार्य प्राप्त करने के लिए कुछ संकेतों का उपयोग करना होगा और उचित रूप से लागू करना होगा।

आपके उदाहरण में, mapcar ''eval के उपयोग के बराबर था।

Answer 3

@ d11wq वहाँ `इस उद्देश्य के लिए funcall 'है। निम्नलिखित काम करता है:

(defun adder-with-let (x) 
    (let ((f #'(lambda (x) (+ x 3)))) 
    (funcall f 3))) 

(adder-with-let 3) ;=> 6 

Answer 4

आप flet उपयोग करने के लिए यदि आप नहीं करना चाहते हैं नहीं है। आप निम्न उदाहरण में let का उपयोग करके परिभाषित एक स्थानीय प्रतीक के समारोह कक्ष में एक समारोह जगह:

(let ((ALocalSymbol)) 
    (fset 'ALocalSymbol (lambda (x) (* 2 x))) 
    (ALocalSymbol 4) 
) 

इस मूल्यांकन 8. वापस आ जाएगी (let ((ALocalSymbol))...) में ALocalSymbol के सामने बोली नोटिस करें। जबकि setq उद्धरण चिह्न, fset नहीं है।

flet प्रकार की एक वाक्य रचनात्मक चीनी है। शून्य-मूल्यवान प्रतीकों को परिभाषित करने के लिए एक सादे-पुराने let का उपयोग करके, आपको यह निर्धारित करने की अनुमति मिलती है कि प्रतीक के "सेल" को सेट किया जाए। फ़ंक्शन सेल सेट करने के लिए आप प्रतीक के मान सेल या fset सेट करने के लिए setq का उपयोग कर सकते हैं।

आशा इस मदद करता है,

पाब्लो