बाध्यकारी वाक्य रचना

Question

मैं Clojure सीख रहा हूँ Clojure समझे और doseq के बारे में पढ़ रहा था जब मैं doseq

(doseq [x [-1 0 1] 
     y [1 2 3]] 
    (prn (* x y))) 

मेरे भ्रम के लिए official Clojure doc पर नीचे की तरह एक उदाहरण देखा अभिव्यक्ति [x [-1 0 1] y [1 2 3]] के साथ है।

यह एक बाध्यकारी अभिव्यक्ति दर्शाता है? मैंने कुछ Google खोज की कोशिश की लेकिन ऐसे किसी भी दस्तावेज में नहीं आया जो इस तरह के एक फॉर्म का वर्णन करता है।

कोई मुझे Clojure में रूपों बंधन के लिए विभिन्न वाक्य रचना अभ्यावेदन को समझने के साथ मदद कर सकते हैं?

Answer 1

यह एक "binding form" है जिसमें यह अभिव्यक्ति से मूल्यों को x नाम से" बाध्य "करता है। इसलिए यह बोलने वाला अर्थ है जो नामों को नामों से जोड़ता है। यह" बाध्यकारी रूपों को नष्ट करने "का हिस्सा है जो बांधता है एक सूची या मानचित्र जैसे यौगिक मूल्य के कुछ हिस्सों के नाम।

"सेटिंग" के बजाय "बाध्यकारी" शब्द यह क्या कर रहा है और कुछ अन्य प्रोग्रामिंग भाषाओं में चर सेट करने में अंतर बताता है। नाम संलग्न है समय यह doseq अंदर प्रपत्र को चलाने के लिए ले जाता है के लिए मूल्य है, तो नाम एक और मूल्य के साथ संलग्न किया करने के लिए जारी किया गया है।

Clojure प्रदान करता है मनमाने ढंग से संरचनात्मक बाध्यकारी है कि नाम (बाँध प्रतीकों)

(doseq [[x1 x2] [[-1 -1] [0 0] [1 1]] 
     y [1 2 3]] 
    (prn (* x1 x2 y))) 

भी एक बाध्यकारी अभिव्यक्ति है आवंटित हालांकि यह डेटा और प्रदान में थोड़ा गहरा लग रहा है भाषा में सबसे अधिक स्थानों में एक मूल्य के किसी भी हिस्से को नाम देने के लिए पहले वेक्टर में प्रति आइटम दो मानों के नाम (और मानते हैं कि उनमें से प्रत्येक में दो संख्याएं हैं) मैं this tutorial on destructuring/binding

Answer 2

का बहुत शौकिया हूं, यह जावा में लूप के लिए घोंसला जैसा है।

(dotest 
    (newline) 
    (println "version 1") 
    (doseq [x [1 2] 
      y [:a :b :c]] 
    (println x y)) 

    (newline) 
    (println "version 2") 
    (doseq [x [1 2]] 
    (doseq [y [:a :b :c]] 
     (println x y)))) 

with results: 
version 1 
1 :a 
1 :b 
1 :c 
2 :a 
2 :b 
2 :c 

version 2 
1 :a 
1 :b 
1 :c 
2 :a 
2 :b 
2 :c 

ध्यान दें कि doseq हमेशा nil देता है, और दुष्प्रभाव (स्क्रीन पर प्रिंट की तरह) पैदा करने के लिए ही अच्छा है: आप भी घोंसले "मैन्युअल" कर सकते हैं।

एक for अभिव्यक्ति इसी तरह बर्ताव करता है, लेकिन मूल्यों की एक (आलसी) अनुक्रम (ध्यान दें कि हम प्रत्येक पाश पर एक सदिश [x y] पैदा कर रहे हैं) देता है:

(newline) 
(println "For generates a (lazy) sequence:" 
    (for [x [1 2] 
     y [:a :b :c]] 
    [x y])) 

परिणाम के साथ

:

For generates a (lazy) sequence: ([1 :a] [1 :b] [1 :c] [2 :a] [2 :b] [2 :c])