क्लोजर में बनाम बाध्यकारी

Question

मैं समझता हूं कि वे *compile-path* सेट करने के लिए एक काम के बाद अलग हैं और कोई नहीं। हालांकि, मुझे मदद चाहिए कि वे अलग क्यों हैं।

let दिए गए बाइंडिंग के साथ एक नया दायरा बनाता है, लेकिन binding ...?

Answer 1

let कुछ मूल्य के लिए एक व्याख्यात्मक रूप से स्कॉप्ड अपरिवर्तनीय उपनाम बनाता है। binding कुछ Var के लिए गतिशील रूप से स्कॉप्ड बाइंडिंग बनाता है।

गतिशील बाध्यकारी का अर्थ है कि आपके binding फॉर्म के अंदर कोड और वह कोड जो कोड कोड करता है (भले ही स्थानीय शब्दावली में नहीं है) नए बाध्यकारी को देखेंगे।

को देखते हुए: के बाद से यह पर चल रही है

user> (binding [x 1] (var-get #'x)) 
1 
user> (let [x 1] (var-get #'x)) 
0 

binding योग्य नामों का उपयोग कर सकते हैं (:

user> (def ^:dynamic x 0) 
#'user/x 

binding वास्तव में एक Var लेकिन let के लिए बाध्यकारी केवल एक स्थानीय उर्फ ​​साथ वर छाया एक गतिशील बनाता है Var एस) और let नहीं कर सकते:

user> (binding [user/x 1] (var-get #'x)) 
1 
user> (let [user/x 1] (var-get #'x)) 
; Evaluation aborted. 
;; Can't let qualified name: user/x 

let -इंटरोडेड बाइंडिंग म्यूटेबल नहीं हैं। binding -introduced बाइंडिंग धागे की स्थानीय स्तर पर परिवर्तनशील हैं:

user> (binding [x 1] (set! x 2) x) 
2 
user> (let [x 1] (set! x 2) x) 
; Evaluation aborted. 
;; Invalid assignment target 

शाब्दिक बनाम गतिशील बंधन:

user> (defn foo [] (println x)) 
#'user/foo 
user> (binding [x 1] (foo)) 
1 
nil 
user> (let [x 1] (foo)) 
0 
nil 

भी Vars, let देखें। बंधन बनाम देना के लिए

Answer 2

binding प्रति-धागा वैश्विक वातावरण

आप उल्लेख किया है, let कहा बाइंडिंग के लिए एक नया गुंजाइश बनाता है में एक नाम करने के लिए एक मूल्य बांधता है।

Answer 3

एक और वाक्यात्मक अंतर:

बंधन के लिए, सभी प्रारंभिक मान से पहले उनमें से किसी वार्स के लिए बाध्य कर रहे हैं मूल्यांकन किया जाता है। यह अलग से अलग है, जहां आप बाद की परिभाषा में पिछले "उपनाम" के मान का उपयोग कर सकते हैं।

user=>(let [x 1 y (+ x 1)] (println y)) 
2 
nil 

user=>(def y 0) 
user=>(binding [x 1 y (+ x 1)] (println y)) 
1 
nil