क्लोजर क्यों सीखें?

एक अच्छी प्रोग्रामिंग भाषा क्या है? उसके पास क्या गुण और विशेषताएं होनी चाहिए? जवाब देना मुश्किल है। यहां संभावित परिभाषाओं में से एक है: एक अच्छा पीएल को सौंपे गए कार्यों को अच्छी तरह से हल करना चाहिए। सब के बाद, हां एक प्रोग्रामर के हाथों में केवल एक उपकरण है। एक उपकरण को हमारे काम में हमारी मदद करनी चाहिए। अंत में, यह इसके निर्माण का कारण है। विभिन्न पीएल विभिन्न समस्याओं (अलग-अलग सफलता के साथ) को हल करने की कोशिश करते हैं। क्लोजर डिजाइन करते समय जो लक्ष्य निर्धारित किया गया था, वह उन कार्यक्रमों को बनाना था जो हमने सरल लिखे थे। और, परिणामस्वरूप, उनके निर्माण, परीक्षण में तेजी लाएं। और सबसे महत्वपूर्ण बात, उनकी समझ, परिवर्तन और रखरखाव के लिए समय कम करें।

लौंग की चट्टानें?

मैं आपको तुरंत चेतावनी दूंगा - कोई भी कोड स्निपेट नहीं होगा जिसमें क्लोजर की शीतलता का प्रदर्शन किया गया हो। इसमें कोई वाक्यांश नहीं होगा जैसे "एक्स भाषा में यह 5 लाइनों और क्लोजर में केवल 4" लिया गया था। यह भाषा की गुणवत्ता के लिए एक घृणित मानदंड है! अंत में, मुझे परवाह नहीं है कि क्या मैं 2 लाइनों में qsort लिख सकता हूं, या मुझे अपनी उंगलियों को 5 से जितना तनाव में रखना होगा - वास्तविक जीवन में मैं लाइब्रेरी फ़ंक्शन का उपयोग करूंगा!

अब आप किसी भी व्यक्ति को लैम्ब्डा के साथ आश्चर्यचकित नहीं करेंगे, वे हर जगह हैं (अच्छी तरह से, लगभग, हालांकि आमतौर पर 8 वें संस्करण के द्वारा वे हर जगह दिखाई देते हैं)। प्रसंस्करण संग्रह (समांतर सहित), सूची अभिव्यक्तियाँ, विभिन्न प्रकार की वाक्य रचना चीनी - यह अब कई भाषाओं में पर्याप्त है। सच में, मैं सिर्फ ऐसे लेखों को मानता हूं। लेकिन भाषाओं की गुणवत्ता की तुलना के लिए ऐसी तुलना पूरी तरह से अनुपयुक्त है! यह एक वाईपी की गति को मापने के लिए है कि कैसे कार्यक्रम "हैलो, दुनिया!" जब तक, हम HQ9 + की गति को मापते हैं । यदि आप इसके बारे में सोचते हैं, तो इस तरह के विवरण बड़े सिस्टम के लिए बहुत महत्वपूर्ण नहीं हैं। जैसे-जैसे परियोजना बढ़ती है, हम कम और कम चिंतित होते हैं कि क्या हम कोष्ठक या इंडेंट, इन्फिक्स या उपसर्ग संकेतन का उपयोग करते हैं। सरणी की राशि को खोजने पर अतिरिक्त लाइन पहले से ही सभी को परेशान करना बंद कर देती है - पहली जगह में एक अलग तरह की समस्याएं सामने आती हैं।

जटिलता

हम जो सिस्टम बनाते हैं वे स्वाभाविक रूप से अस्थिर होते हैं। आवश्यकताएं नहीं बदलीं तो बहुत अच्छा होगा। यह बहुत ही अद्भुत है अगर विकास की शुरुआत में सभी स्थितियों को पहले से समझ लेना संभव होगा। काश, वास्तविक जीवन में हमें लगातार खत्म करना, फिर से तैयार करना, सुधारना, फिर से लिखना, बदलना, अनुकूलन करना पड़ता है। सबसे अप्रिय बात यह है कि समय के साथ, प्रणाली की जटिलता केवल बढ़ती है। लगातार, लगातार। विकास की शुरुआत में, सब कुछ सरल और पारदर्शी है, कोई भी परिवर्तन जल्दी से किया जाता है, कोई "बैसाखी" नहीं। सौंदर्य। समय के साथ, स्थिति इतनी रोशन और हंसमुख हो जाती है। यहां तक ​​कि कोड का मामूली संपादन भी संभवतः सिस्टम के व्यवहार में हिमस्खलन जैसे परिवर्तनों को जन्म दे सकता है। आपको सावधानीपूर्वक अध्ययन करना होगा, कोड का विश्लेषण करना होगा, प्रत्येक परिवर्तन से दुष्प्रभावों की भविष्यवाणी करने का प्रयास करना होगा। वास्तव में, समय के साथ, हम सचमुच हमारे परिवर्तनों के सभी संभावित परिणामों का अच्छी तरह से विश्लेषण नहीं कर सकते हैं।

स्वभाव से एक व्यक्ति एक समय में सीमित जानकारी ही देख सकता है। जैसे-जैसे प्रोजेक्ट बढ़ता है, वैसे-वैसे आंतरिक कनेक्शनों की संख्या बढ़ती जाती है। इसके अलावा, अधिकांश कनेक्शन अंतर्निहित हैं। हमारे लिए यह अधिक कठिन होता जा रहा है कि हमें अपने प्रमुखों की आवश्यकता क्या है। और इस समय, टीम बढ़ रही है, टीम बदल रही है - नए लोग अब पूरे प्रोजेक्ट को नहीं जानते हैं। जिम्मेदारियों का अलगाव होता है, जिससे और भी भ्रम हो सकता है। धीरे-धीरे, हमारी प्रणाली जटिल हो जाती है।

इससे कैसे निपटें? प्रतिगमन परीक्षणों की अधिकतम कवरेज और प्रत्येक परिवर्तन के बाद उन्हें चलाते हैं? टेस्ट बेहद उपयोगी हैं, लेकिन वे केवल एक सुरक्षा रस्सी हैं। परीक्षण पास नहीं हुए - कुछ सही नहीं है, हमें एक समस्या है। यह लक्षणों का एक इलाज है, लेकिन परीक्षण समस्या के सार को ठीक नहीं करते हैं। सख्त दिशा-निर्देश और पैटर्न का व्यापक उपयोग? नहीं, समस्या स्थानीय कठिनाइयों में नहीं है। हम सिर्फ यह समझना बंद कर देते हैं कि घटक हमारे कोड में कैसे इंटरैक्ट करते हैं, बहुत सारे अंतर्निहित लिंक हैं। शायद निरंतर रीफ़ैक्टरिंग? यह रामबाण नहीं है; निम्न-स्तरीय समाधानों से जटिलता नहीं बढ़ती है। वास्तव में, समस्या को व्यापक रूप से संबोधित किया जाना चाहिए। और महत्वपूर्ण उपकरणों में से एक सही उपकरण है। एक अच्छी प्रोग्रामिंग भाषा हमें सरल और पारदर्शी कार्यक्रम लिखने में मदद करनी चाहिए।

सरल और आसान

लेकिन "सरल" का मतलब "आसान" बिल्कुल नहीं है। ये अलग-अलग अवधारणाएँ हैं। इस विषय पर, रिच हिकी (क्लोजर के लेखक) ने प्रसिद्ध रिपोर्ट को सिंपल मेड ईज़ी भी बनाया। स्लाइड का अनुवाद हैबर पर प्रकाशित हुआ है। सरलता एक वस्तुनिष्ठ अवधारणा है। यह जटिलता (जटिलता) की कमी, इंटरव्यूविंग की अनुपस्थिति, भ्रम, कनेक्शन की एक छोटी संख्या है। दूसरी ओर, "आसान" बहुत व्यक्तिपरक है। क्या बाइक चलाना आसान है? शतरंज का खेल जीतें? जर्मन बोलो मैं जर्मन नहीं जानता, लेकिन यह कहने का कोई कारण नहीं है "इस भाषा की आवश्यकता नहीं है, यह बहुत जटिल है।" यह मेरे लिए मुश्किल है , और फिर भी केवल इसलिए कि मैं इसे नहीं जानता।

हम सभी को फंक्शन कॉल f(x, y) कॉल करने के लिए उपयोग किया जाता है। हम ओओपी के ढांचे में प्रोग्रामिंग के लिए उपयोग किए जाते हैं। यह आम बात है। लेकिन वास्तव में, फेफड़े जरूरी सरल नहीं है। हम बस कुछ चीजों की जटिलता के लिए अभ्यस्त हो जाते हैं, इसे अनदेखा करना शुरू कर देते हैं, इसे स्वीकार करते हैं। समारोह का उदाहरण:

 (defn select "Returns a set of the elements for which pred is true" {:added "1.0"} [pred xset] (reduce (fn [sk] (if (pred k) s (disj sk))) xset xset)) 

बहुत अच्छा लग रहा है ... अजीब है ! आपको भाषा सीखने में कुछ समय बिताने की ज़रूरत है, इसकी अवधारणाओं में महारत हासिल करना, ताकि यह आसान हो जाए। लेकिन सादगी (या जटिलता) निरंतर है। यदि हम उपकरण का अच्छी तरह से अध्ययन करते हैं, तो आंतरिक निर्भरता की संख्या वैसे भी नहीं बदलेगी। यह अधिक जटिल या सरल नहीं होगा, हालांकि यह हमारे लिए आसान होगा।

एक परिचित उपकरण अभी, तुरंत, सबसे अच्छा परिणाम दे सकता है, लेकिन लंबी अवधि में, सबसे सरल समाधान सर्वोत्तम परिणाम दिखाता है।

साइड इफेक्ट

हमारे कार्यक्रमों में कठिनाई के स्रोत क्या हैं? उनमें से एक साइड इफेक्ट है। आप उनके बिना पूरी तरह से नहीं कर सकते, लेकिन हम उन्हें स्थानीय कर सकते हैं। और भाषा को इसमें हमारी मदद करनी चाहिए ।

क्लोजर एक कार्यात्मक भाषा है, यह हमें शुद्ध कार्यों को लिखने के लिए प्रोत्साहित करती है। ऐसे कार्यों का परिणाम केवल इनपुट मापदंडों पर निर्भर करता है। अपने दिमाग को "हम्म" रैक करने की आवश्यकता नहीं है, लेकिन अगर मैं इस फ़ंक्शन को कॉल करने से पहले इसे लॉन्च करता हूं तो क्या होता है। कोई इनपुट है तो कोई वीकेंड है। हम कितनी बार भी फंक्शन चलाते हैं, उसका रिजल्ट वही होगा। इससे परीक्षण बेहद आसान हो जाता है। कॉल के विभिन्न आदेशों को क्रमबद्ध करने या सही बाहरी स्थिति को फिर से बनाने (अनुकरण) करने की आवश्यकता नहीं है।

शुद्ध कार्यों का विश्लेषण करना आसान है, आप सचमुच उनके साथ "चारों ओर खेल" कर सकते हैं, देखें कि वे लाइव डेटा पर कैसे व्यवहार करते हैं। कोड डिबग करने के लिए आसान। हम हमेशा एक शुद्ध फ़ंक्शन के साथ समस्या को पुन: उत्पन्न कर सकते हैं - बस उन मापदंडों में पास करें जो इसके लिए त्रुटि का कारण बनते हैं, क्योंकि फ़ंक्शन का परिणाम उस पर निर्भर नहीं करता है जो पहले किया गया था। शुद्ध कार्य अत्यंत सरल हैं, भले ही वे बहुत से काम करते हों।

बेशक, क्लजोर उच्च-क्रम के कार्यों, उनकी रचना का समर्थन करता है।

 ((juxt dec inc) 1) ; => [0 2] ((comp str *) 1 2 3) ; => "6" (map (partial * 10) [1 2 3]) ; => [10 20 30] (map (comp inc inc) [1 2 3]) ; => [3 4 5] 

क्लोजर एक शुद्ध भाषा नहीं है, और कार्यों के दुष्प्रभाव हो सकते हैं। उदाहरण के लिए, println एक फ़ंक्शन कॉल है, एक क्रिया है। यह महत्वपूर्ण है कि इस तरह के कार्यों का बहुत सार बाहरी दुनिया के साथ बातचीत में निहित है। फ़ाइल के लिए एक मूल्य का उत्पादन करने के लिए, एक HTTP अनुरोध भेजें, SQL निष्पादित करें - ये सभी क्रियाएं उनके द्वारा बनाए गए साइड इफेक्ट से अलगाव में अर्थहीन हैं। इसलिए, ऐसे कार्यों (स्वच्छ और गंदे) को अलग करने के लिए यह बहुत उपयोगी है।

लेकिन उनके (गंदे कार्य) राज्य नहीं हैं। वे केवल बाहरी दुनिया के साथ बातचीत के साधन के रूप में काम करते हैं। जैसा कि हम बाद में देखेंगे, क्लोजर अप्रत्यक्ष लिंक का उपयोग करके हमारे कार्यक्रम की स्थिति को अलग करता है।

Immutabelnost

क्लोजर में सभी डेटा संरचनाएं अपरिवर्तनीय हैं। वेक्टर तत्व को बदलने का कोई तरीका नहीं है। हम सब कर सकते हैं एक नया वेक्टर बना है जिसमें एक तत्व बदल गया है। एक बहुत महत्वपूर्ण बिंदु यह है कि क्लोजर सभी मानक संग्रह संचालन के लिए एल्गोरिथम जटिलता (समय और स्मृति में) को बरकरार रखता है। वैक्टर के लिए ओ (1) के बजाय, लगभग, हमारे पास ओ (लॉग ₃₂ (एन)) है। व्यवहार में, लाखों तत्वों के संग्रह के लिए, lg ₃₂ (N) 5 से अधिक नहीं है।

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

 (def a [1 2 3 4 5 6 7 8]) ; a -> [1 2 3 4 5 6 7 8] (def b (assoc a 3 999)) ;b -> [1 2 3 999 5 6 7 8] 

बॉक्स से बाहर, क्लॉजुर एकल जुड़ी हुई सूचियों, वैक्टर, हैश टेबल, लाल-काले पेड़ों का समर्थन करता है। एक सतत कतार कार्यान्वयन है (आप स्टैक के लिए सूची या वेक्टर का उपयोग कर सकते हैं)। और सब कुछ अपरिवर्तनीय है। प्रदर्शन में सुधार करने के लिए, आप अपने खुद के रिकॉर्ड प्रकार बना सकते हैं।

 (defrecord Color [red green blue]) (def a (Color. 0.5 0.6 0.7) ; a => {:red 0.5, :green 0.6, :blue 0.7} 

यहां हम 3-फील्ड संरचना की घोषणा करते हैं। क्लोजर कंपाइलर 5 फ़ील्ड्स (2 "अतिरिक्त") के साथ एक ऑब्जेक्ट बनाएगा। मेटाडेटा के लिए एक क्षेत्र, हमारे मामले में यह शून्य होगा। वास्तविक डेटा के लिए 3 फ़ील्ड। और एक और क्षेत्र - अतिरिक्त कुंजी के लिए। यहां तक ​​कि अगर हमारे कार्यक्रम में गति बढ़ाने के लिए हम खेतों की एक स्पष्ट गणना के साथ एक संरचना की घोषणा करते हैं, तो क्लोजर अभी भी हमें अतिरिक्त मूल्यों को जोड़ने का अवसर छोड़ देता है।

 (defrecord Color [red green blue]) (def b (assoc a :alpha 0.1)) ; b => {:alpha 0.1, :red 0.5 :green 0.6, :blue 0.7} 

और हां, क्लॉज्योर में डेटा संरचनाओं के लिए एक विशेष वाक्यविन्यास है:

 ;  [1 2 3] ; - {:x 1, :y 2} ;  #{"a" "b" "c"} 

राज्य

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

4 प्रकार के मानक लिंक हैं:

• var - थ्रेड-लोकल वैरिएबल का एक एनालॉग, जिसका उपयोग प्रासंगिक डेटा सेट करने के लिए किया जाता है: डेटाबेस से वर्तमान कनेक्शन, वर्तमान HTTP अनुरोध, गणितीय अभिव्यक्तियों के लिए सटीकता पैरामीटर और पसंद;
• atom - परमाणु सेल , आपको राज्य को समकालिक रूप से अपडेट करने की अनुमति देता है , लेकिन समन्वित नहीं ;
• agent - अभिनेता के लिए एक हल्का एनालॉग (हालांकि, एक मायने में, वे एंटीपोड हैं, उस पर अधिक), राज्य के साथ अतुल्यकालिक काम के लिए सेवा करते हैं;
• ref - ट्रांसएक्शनल मेमोरी की कोशिकाएं, राज्य के साथ तुल्यकालिक और समन्वित कार्य प्रदान करती हैं।

सभी वैश्विक चर var (कार्यों सहित) में संग्रहीत हैं। इसलिए, उन्हें "स्थानीय रूप से" पुनर्परिभाषित किया जा सकता है।

 (def ^:dynamic *a* 1) (println a) ; => 1 (binding [a 42] (println a)) ; => 42 

यहां हमने संकलक को बताया कि चर a गतिशील होना चाहिए, अर्थात्। थ्रेडलोक के अंदर संग्रहीत। ThreadLocal का उपयोग प्रदर्शन को थोड़ा कम करता है, इसलिए इसे डिफ़ॉल्ट रूप से सभी var कोशिकाओं के लिए लागू नहीं किया जाता है। लेकिन, यदि आवश्यक हो, तो निर्माण के बाद किसी भी var सेल को गतिशील बनाया जा सकता है (जो अक्सर परीक्षणों में उपयोग किया जाता है)।

परीक्षणों में, आप पूरे कार्यों को बदल सकते हैं।

 ;     ,   .. (defn some-function-with-side-effect [x] ...) ;       (defn another-function [x] ...) (deftest just-a-test ... (binding [some-function-with-side-effect (fn [x] ...)] ;  mock- (another-function 123)) ...) 

deref सभी लिंक deref (मूल्य प्राप्त करें) ऑपरेशन का समर्थन करते हैं। var कोशिकाओं के लिए, यह इस तरह दिखता है:

 ;   #'a (def a 123) (println a) ; => 123 (println #'a) ; => #'user/a (println (deref #'a)) ; => 123 

एक सेल एक मान (अपरिवर्तनीय) को संग्रहीत करता है, लेकिन खुद एक अलग इकाई है। deref फ़ंक्शन के लिए एक विशेष सिंटैक्स पेश किया deref (हाँ, यह सिर्फ चीनी है)। यहां atom का उपयोग करने का एक उदाहरण है।

 (let [x (atom 0)] (println @x) ; => 0 (swap! x inc) ; CAS- (println @x)) ; => 1 

swap! समारोह swap! एक परमाणु और एक "उत्परिवर्तन" कार्य करता है। उत्तरार्द्ध परमाणु का वर्तमान मूल्य लेता है, और एक नया वापस करना चाहिए। लगातार डेटा संरचनाएं यहां बहुत काम आती हैं। उदाहरण के लिए, हम एक परमाणु में एक लाख तत्वों के वेक्टर को स्टोर कर सकते हैं, लेकिन "म्यूटिंग" फ़ंक्शन को कैस के लिए जल्दी से पर्याप्त रूप से निष्पादित किया जाएगा (हमें याद है कि लगातार संग्रह पर संचालन की जटिलता सामान्य, परिवर्तनशील लोगों के लिए समान है)। या हम हैश टेबल पर कुछ फ़ील्ड अपडेट कर सकते हैं:

 (def user (atom {:login "theuser" :email "theuser@example.com"})) (swap! account assoc :phone "12345") ;    (swap! account (fn [x] (assoc x :phone "12345"))) 

यह महत्वपूर्ण है कि फ़ंक्शन साफ ​​है, क्योंकि यह कई बार निष्पादित हो सकता है। हम ऐसा कुछ नहीं लिख सकते (नहीं करना चाहिए):

 (swap! x (fn [x] (insert-new-record-to-db x) (inc x))) 

एजेंटों

एजेंट एक ऐसी स्थिति का समर्थन करने के लिए सेवा करते हैं जो सीधे दुष्प्रभावों से संबंधित है। विचार सरल है। हमारे पास एक सेल है, कार्यों की एक कतार इसके साथ "संलग्न" है। फ़ंक्शंस को एक-एक करके इस सेल में संचित किया जाता है, फ़ंक्शन का परिणाम एक नया मान बन जाता है। सब कुछ एक अलग थ्रेड पूल में अतुल्यकालिक रूप से गणना की जाती है।

 (def a (agent 0)) ;   (send a inc) (println @a) ; => 1 (send a (fn [x] (Thread/sleep 100) (inc x))) (println @a) ; => 1 ;  100  (println @a) ; => 2 

एजेंट अपने मूल्य को एसिंक्रोनस रूप से अपडेट करते हैं। लेकिन हम किसी भी समय एजेंट की स्थिति का पता लगा सकते हैं। एजेंट एक दूसरे को संदेश भेज सकते हैं; भेजते समय, संदेश भेजने में देरी हो जाती है जब तक कि भेजने वाला अपनी स्थिति को अपडेट नहीं करता है। दूसरे शब्दों में, यदि एक एजेंट में एक अपवाद को फेंक दिया जाता है, तो इससे भेजे गए संदेश कहीं भी नहीं भेजे जाएंगे।

 (def a (agent 0)) (def b (agent 0)) (send a (fn [x] (send b inc) ;    b (throw (Exception. "Error")))) (println @b) ; -> 0,      

अभिनेताओं के मॉडल के साथ एक निश्चित सादृश्य स्वयं का सुझाव देता है । वे समान हैं, लेकिन मौलिक अंतर हैं। एजेंटों की स्थिति स्पष्ट है, किसी भी समय आप deref को कॉल कर सकते हैं और एजेंट का मूल्य प्राप्त कर सकते हैं। यह अभिनेताओं के विचार का खंडन करता है, जहां हम संदेश भेजने और प्राप्त करने से अप्रत्यक्ष रूप से राज्य का पता लगा सकते हैं। अभिनेताओं के मामले में, हम यह भी सुनिश्चित नहीं कर सकते हैं कि उनकी स्थिति का साक्षात्कार करने के बाद, हम "गलती से" इसे नहीं बदलेंगे। एजेंट इस अर्थ में पूरी तरह से विश्वसनीय है - इसका राज्य केवल send और send-off कार्यों के साथ बदला जा सकता है (जो केवल थ्रेड पूल में भिन्न होता है जिसमें हमारे संदेश को संसाधित किया जाएगा)।

दूसरा मुख्य अंतर यह है कि एजेंट कार्यक्षमता को बदलने और जोड़ने के लिए खुले हैं। एक अभिनेता के व्यवहार को बदलने का एकमात्र तरीका अपने कोड को फिर से लिखना है। एजेंट केवल लिंक हैं, उनका अपना व्यवहार नहीं है। हम एक नया फ़ंक्शन लिख सकते हैं और इसे एजेंट कतार में भेज सकते हैं।

अभिनेता हमारे कार्यक्रम की स्थिति को छोटे भागों में विभाजित करने की कोशिश कर रहे हैं जो अलग-अलग आंसू या अलग करना आसान है। संदेश भेजने के लिए स्थिति अद्यतन और पढ़ने के संचालन में कमी आती है। यह कभी-कभी बेहद उपयोगी होता है (उदाहरण के लिए, जब कई नोड्स पर एक एरलांग प्रोग्राम चलाते हैं)। लेकिन अधिक बार यह आवश्यक नहीं है। कभी-कभी विपरीत भी। इसलिए, बड़ी मात्रा में जानकारी संग्रहीत करने के लिए एजेंटों के लिए यह सुविधाजनक है कि उन्हें प्रवाह के बीच गड़बड़ी करने की आवश्यकता है: कैश, सत्र, गणितीय गणना के मध्यवर्ती परिणाम आदि।

अभिनेताओं के लिए, हम बहुत सारे संदेशों को ठीक करते हैं जिनका वह जवाब दे सकता है (वह बाकी को गलत मानता है)। संदेशों का क्रम भी महत्वपूर्ण है, क्योंकि वे संभावित रूप से दुष्प्रभाव हो सकते हैं। यह उनका सार्वजनिक अनुबंध है। एक एजेंट के लिए, हम केवल उस डेटा को रिकॉर्ड करते हैं जो इसमें संग्रहीत किया जा सकता है, उनकी संरचना। यह जोर देना बहुत महत्वपूर्ण है कि एजेंट अभिनेताओं को बदलने की कोशिश में बिल्कुल भी नहीं हैं। ये अलग-अलग अवधारणाएं हैं, और उनका दायरा अलग-अलग है।

जैसा कि उल्लेख किया गया है, एजेंट एसिंक्रोनस रूप से काम करते हैं। हम घटनाओं की श्रृंखला (एजेंट से एजेंट तक संदेश भेजना) का निर्माण कर सकते हैं। लेकिन अकेले एजेंटों की मदद से, हम समन्वित तरीके से अपने कार्यक्रम की स्थिति को बदलने में सक्षम नहीं होंगे।

एसटीएम

सॉफ्टवेयर ट्रांजेक्शनल मेमोरी क्लोजर की प्रमुख विशेषताओं में से एक है। MVCC द्वारा कार्यान्वित किया गया। और तुरंत एक उदाहरण:

 (def account1 (ref 100) (def account2 (ref 0)) (dosync (alter account1 - 30) (alter account2 + 30)) 

हम एक मूल्य बढ़ाते हैं और साथ ही साथ एक और घटाते हैं। अगर कुछ गलत हुआ (अपवाद), तो पूरा लेनदेन रद्द कर दिया जाएगा:

 (println @account1) ; => 70 (println @account2) ; => 30 (dosync (alter account1 * 0) (alter account2 / 0)) ; => ArithmeticException ;    (println @account1) ; => 70 (println @account2) ; => 30 

सामान्य ACID के समान, लेकिन केवल स्थायित्व के बिना। लेन-देन में प्रवेश करते समय, सभी लिंक फ्रीज होने लगते हैं, उनके मूल्य पूरे लेनदेन की अवधि के लिए तय किए जाते हैं। यदि, किसी लिंक को पढ़ते / लिखते समय, यह पता चलता है कि उसने पहले ही अपना मूल्य बदल दिया है (एक और लेन-देन पूरा हो गया है और हमारे जीवन को खराब कर दिया है), तो वर्तमान लेनदेन को फिर से शुरू किया जाता है। इसलिए, लेन-देन (इनपुट-आउटपुट, परमाणुओं के साथ काम) के अंदर कोई दुष्प्रभाव नहीं होना चाहिए। और यहां एजेंट काम आते हैं।

 (def a (ref 0)) (def b (ref 0)) (def out-agent (agent nil)) (dosync (println "transaction") (alter a inc) ;      (let [a-value @a b-value @b] (send-off out-agent (fn [_] (println "a" a-value "b" b-value)))) (alter b dec)) ;      

एजेंटों के लिए सभी संदेश उस क्षण का पालन करते हैं जब लेनदेन पूरा हो जाता है। हमारे उदाहरण में, लिंक को a और b बदलने से लेनदेन फिर से शुरू हो सकता है, "लेनदेन" शब्द को कई बार मुद्रित किया जा सकता है। लेकिन एजेंट के अंदर कोड बिल्कुल एक बार निष्पादित किया जाएगा, और लेनदेन पूरा होने के बाद।

संभव के रूप में एक दूसरे के साथ हस्तक्षेप करने से विभिन्न लेनदेन रखने के लिए, क्लोझर में लिंक मूल्यों का इतिहास रखते हैं। डिफ़ॉल्ट रूप से, यह केवल अंतिम मान है, लेकिन जब कोई विरोधाभास होता है (एक लेनदेन लिखता है और दूसरा पढ़ता है), तो एक विशिष्ट लिंक के लिए, संग्रहीत इतिहास का आकार एक (5 मान तक) बढ़ जाता है। यह मत भूलो कि हम सामान्य संरचनात्मक तत्वों को साझा करने वाले लिंक में लगातार संरचनाओं को संग्रहीत करते हैं। इसलिए, क्लोजर में इस तरह की कहानी को संग्रहीत करना स्मृति की खपत के मामले में बहुत सस्ता है।

एसटीएम लेनदेन हमारे कोड को बदलते समय हमें परेशान नहीं करता है। वर्तमान लेनदेन में एक या किसी अन्य लिंक का उपयोग किया जा सकता है या नहीं, इसका विश्लेषण करने की आवश्यकता नहीं है। वे सभी उपलब्ध हैं, और हम मौजूदा लिंक में पूरी तरह से पारदर्शी रूप से नए लिंक जोड़ सकते हैं। लिंक एक दूसरे के साथ बातचीत नहीं करते हैं। उदाहरण के लिए, साधारण ताले का उपयोग करते समय, हमें लॉक / अनलॉक ऑर्डर की निगरानी करने की आवश्यकता होती है ताकि गतिरोध पैदा न हो।

समवर्ती पहुंच के साथ, रीडर लेनदेन एक दूसरे को ब्लॉक नहीं करते हैं, बहुत कुछ ReadWriteLock का उपयोग करके। इसके अलावा, लेन-देन करने वाले लेखक पाठकों को ब्लॉक नहीं करते हैं! यहां तक ​​कि अगर कोई लेन-देन वर्तमान में चल रहा है जो लिंक को बदलता है, तो हम बिना ब्लॉक किए मूल्य प्राप्त कर सकते हैं।

एजेंट और एसटीएम लिंक एक दूसरे के पूरक हैं। पूर्व राज्य में समन्वित परिवर्तन के लिए उपयुक्त नहीं हैं, बाद वाले आपको दुष्प्रभावों के साथ काम करने की अनुमति नहीं देते हैं। लेकिन उनका संयुक्त उपयोग हमारे कार्यक्रमों को "शास्त्रीय" टूल (म्यूटेक्स, सेमाफोर्स, आदि) का उपयोग करने की तुलना में अधिक पारदर्शी और सरल (कम भ्रमित) बनाता है।

metaprogramming

कई भाषाओं में अब कुछ प्रकार के मेटाप्रोग्रामिंग उपकरण हैं। ये जावा के लिए एस्पेक्टज, ग्रूवी के लिए एएसटी रूपांतरण, पायथन के लिए डेकोरेटर और मेटाक्लास, विभिन्न प्रतिबिंब हैं।

लिस्प परिवार के सदस्य के रूप में क्लोजर, इन उद्देश्यों के लिए मैक्रोज़ का उपयोग करता है। उनकी मदद से, हम भाषा को भाषा के माध्यम से ही कार्यक्रम (विस्तार) कर सकते हैं। मैक्रो एक "साधारण" फ़ंक्शन है, जिसमें एकमात्र अंतर यह है कि इसे प्रोग्राम संकलन के दौरान निष्पादित किया जाता है। अभी तक संकलित कोड मैक्रो इनपुट को पारित नहीं किया गया है, मैक्रो निष्पादन का परिणाम नया कोड है जो कंपाइलर पहले से ही संकलित है।

 (defmacro unless [pred ab] `(if (not ~pred) ~a ~b)) (unless (> 1 10) (println "1 > 10. ok") (println "1 < 10. wat")) 

हमने अपनी स्वयं की नियंत्रण संरचना (उलटा संस्करण if) बनाई । आपको केवल एक फ़ंक्शन लिखने की ज़रूरत है!

मैक्रोज़ व्यापक रूप से क्लोजर में उपयोग किया जाता है। वैसे, भाषा में निर्मित कई ऑपरेटर वास्तव में मैक्रोज़ हैं। उदाहरण के लिए, यहां एक कार्यान्वयन है or:

 (defmacro or ([] nil) ([x] x) ([x & next] `(let [or# ~x] (if or# or# (or ~@next))))) 

यहां तक कि defnसिर्फ एक मैक्रो, में खुलासा defऔर fn। वैसे, मैक्रोज़ का उपयोग करके विनाशकारी भी लागू किया जाता है।

 (let [[ab] [1 2]] (+ ab)) ;   - ... (let* [vec__123 [1 2] a (clojure.core/nth vec__123 0 nil) b (clojure.core/nth vec__123 1 nil)] (+ ab)) 

हाल ही में, जावा में प्रयास-के-संसाधन दिखाई दिए हैं । उसी समय, हमने जावा के 7 वें संस्करण के लिए केवल कुछ वर्षों तक इंतजार किया। क्लोजर के लिए, बस कुछ पंक्तियाँ लिखें:

 (defmacro with-open [[vr] & body] `(let [~r ~v] (try ~@body (finally (.close ~v))))) 

अन्य भाषाओं में, स्थिति बेहतर है, लेकिन अभी भी आदर्श से बहुत दूर है। महत्वपूर्ण बात भाषा में किसी विशेष निर्माण की उपस्थिति नहीं है, लेकिन अपनी खुद की जोड़ने की क्षमता है । इसलिए, यह आश्चर्यजनक नहीं है कि, उदाहरण के लिए, क्लॉज्योर के लिए मेल खाने वाला पैटर्न एक अलग प्लग-इन लाइब्रेरी के रूप में लागू किया गया है । इस तरह की चीजों को भाषा के मूल में शामिल करने की कोई जरूरत नहीं है, उन्हें मैक्रो के रूप में लागू करना अधिक समीचीन है। स्थिति मोनड समर्थन , तार्किक प्रोग्रामिंग , उन्नत त्रुटि हैंडलिंग और अन्य भाषा एक्सटेंशन के साथ समान है। यहां तक ​​कि एक वैकल्पिक स्थिर टाइपिंग भी है !

कोई भी DSL बनाने की सुविधा का उल्लेख नहीं कर सकता है। क्लोजर के लिए उनमें से एक बहुत हैं। यह औरHTML की पीढ़ी है, और HTTP अनुरोध मार्ग , और साथ काम रिलेशनल डेटाबेस डेटा , और के साथ काम करने बाइनरी प्रोटोकॉल और मान्यता डेटा ... उन्हें आसानी से बनाने के लिए और प्रभावी ढंग से (हालांकि इस मामले में आप को पता है जब रोकने की जरूरत है)।

क्लोजर (सभी लिस्प की तरह भाषाओं) की एक बहुत महत्वपूर्ण विशेषता है - यह होमो- अद्वितीय है । दूसरे शब्दों में, कार्यक्रम के स्रोत कोड के लिए एक अलग प्रस्तुति की आवश्यकता नहीं है, आपको अतिरिक्त बनाने की आवश्यकता नहीं हैकुछ अतिरिक्त एएसटी-ट्री के रूप में अमूर्तता के स्तर, कार्यक्रम यह पेड़ है। इसके अलावा, यह पेड़ किसी विशेष संरचना से नहीं है, ये साधारण सूची, वैक्टर और प्रतीक हैं। और हम अपने प्रोग्राम के साथ उसी तरह से काम कर सकते हैं जैसे कि नियमित डेटा के साथ।

 (defn do2 [x] (list 'do xx)) (do2 '(println 1)) ; => '(do (println 1) (println 1)) ;   ; => (list 'do (list 'println 1) (list 'println 1)) 

उनकी सारी शक्ति के लिए, क्लोजर में मैक्रोज़ कार्यक्रम की पठनीयता को प्रभावित नहीं करते हैं (जब तक, निश्चित रूप से, आप उन्हें मॉडरेशन में उपयोग करते हैं)। आखिरकार, एक मैक्रो सिर्फ एक फ़ंक्शन है, और हम हमेशा विशिष्ट रूप से निर्धारित कर सकते हैं कि वर्तमान संदर्भ में किस फ़ंक्शन का उपयोग किया जाता है। उदाहरण के लिए, यदि हम कोड देखते हैं, तो (dosomething [ab] c)यह पता लगाना आसान है कि नाम के पीछे क्या छिपा है dosomething, बस फ़ाइल की शुरुआत में देखें (जहां अन्य मॉड्यूल आयात किए जाते हैं)। यदि यह एक स्थूल है, तो इसके शब्दार्थ निरंतर और प्रसिद्ध हैं। इस कोड को समझने के लिए हमें उन्नत IDEs की आवश्यकता नहीं है। हालांकि, निश्चित रूप से, उन्नत विकास वातावरण जगह में एक मैक्रो को "तैनात" कर सकते हैं, जिससे आपको यह देखने की अनुमति मिलती है कि कंपाइलर हमारे कार्यक्रम को क्या मोड़ देगा।

बहुरूपता

पोलीमॉर्फिक फ़ंक्शंस बनाने के लिए क्लोजर में 2 तंत्र हैं। प्रारंभ में, भाषा ने केवल मल्टीमिथोड्स का समर्थन किया - एक शक्तिशाली उपकरण, लेकिन सबसे अधिक बार अत्यधिक। संस्करण 1.2 (और संस्करण 1.5.1 वर्तमान में प्रासंगिक है) से शुरू होकर, भाषा - प्रोटोकॉल में एक नई अवधारणा जोड़ी गई है।

प्रोटोकॉल जावा इंटरफेस के समान हैं, लेकिन एक दूसरे से विरासत में नहीं मिल सकते हैं। प्रत्येक प्रोटोकॉल कार्यों का एक सेट का वर्णन करता है।

 (defprotocol IShowable (show [this])) ; ... (map show [1 2 3]) 

इसके द्वारा हम 2 संस्थाओं की घोषणा करते हैं - प्रोटोकॉल ही, साथ ही फ़ंक्शन show। यह एक नियमित क्लोजर फ़ंक्शन है, जिसे कहा जाता है, पहले तर्क के प्रकार के आधार पर सबसे उपयुक्त कार्यान्वयन की खोज करता है। अलग-अलग, हम आवश्यक डेटा संरचनाओं की घोषणा करते हैं, और उनके लिए प्रोटोकॉल के कार्यान्वयन का संकेत देते हैं।

 (defrecord Color [red green blue] IShowable (show [this] (str "<R" (:red this) " G" (:green this) " B" (:blue this)))) 

आप तृतीय-पक्ष प्रकार (यहां तक ​​कि अंतर्निहित) के लिए एक प्रोटोकॉल लागू कर सकते हैं।

 (extend-protocol IShowable String (show [this] (str "string " this)) clojure.lang.IPersistentVector (show [this] (str "vector " this)) Object (show [this] "WAT")) (show "123") ; => "string 123" (show [1 2 3]) ; => "vector [1 2 3]" (show '(1 2 3)) ; => "WAT" 

आप मौजूदा प्रकारों में प्रोटोकॉल कार्यान्वयन जोड़ सकते हैं, भले ही हमारे पास स्रोत कोड तक पहुंच न हो। बाइटकोड या इसी तरह की चाल के साथ कोई जादुई जोड़तोड़ नहीं हैं। क्लॉजुर एक वैश्विक तालिका बनाता है -> , जब प्रोटोकॉल विधि कहा जाता है, तो इस तालिका में पहले तर्क के प्रकार द्वारा पदानुक्रम को ध्यान में रखते हुए खोजा जाता है। इस प्रकार, वैश्विक तालिका को अद्यतन करने के लिए प्रोटोकॉल के लिए एक नए कार्यान्वयन की घोषणा नीचे आती है।

लेकिन कभी-कभी प्रोटोकॉल पर्याप्त नहीं होते हैं। उदाहरण के लिए, दोहरी समय-निर्धारण के लिए । इस (और न केवल) मामलों में, मल्टीमिथोड काम में आते हैं।। मल्टीमिथोड घोषित करते समय, हम एक विशेष साइड फंक्शन-डिस्पैचर निर्दिष्ट करते हैं। प्रेषणकर्ता मल्टीमिथोड के समान तर्क प्राप्त करता है। अंतिम कार्यान्वयन की खोज पहले से ही डिस्पैचर द्वारा लौटाए गए मूल्य से की जाती है। यह एक प्रकार, कीवर्ड या वेक्टर हो सकता है। वेक्टर के मामले में, कई मूल्यों का उपयोग करके सबसे उपयुक्त कार्यान्वयन के लिए एक खोज की जाती है।

 (defmulti convert (fn [obj target-type] [(class obj) target-type])) (defmethod convert [String Integer] [x _] (Integer/parseInt x)) (defmethod convert [String Long] [x _] (Long/parseLong x)) (defmethod convert [Object String] [x _] (.toString x)) (defmethod convert [java.util.List String] [x _] (str "V" (vec x))) (convert "123" Integer) ; -> 123 (convert "123" Long) ; -> 123 (convert 123 String) ; -> "123" (convert [1 2 3] String) ; -> "V[1 2 3]" 

यहां हमने एक सार फ़ंक्शन की घोषणा की, जिसका कार्यान्वयन पहले तर्क के प्रकार और दूसरे के मूल्य के आधार पर चुना गया है (यह एक वर्ग होना चाहिए)। बेशक, क्लोजर एक उपयुक्त कार्यान्वयन की तलाश में प्रकार पदानुक्रम को ध्यान में रखता है। प्रकार उपयोग करने के लिए सुविधाजनक हैं, लेकिन उनकी पदानुक्रम कड़ाई से तय की गई है। लेकिन हम कीवर्ड से अपनी स्वयं की तदर्थ श्रेणी बना सकते हैं।

 ;   "-" (derive ::rect ::shape) (derive ::square ::rect) (derive ::circle ::shape) (derive ::triangle ::shape) (defmulti perimeter :type) ;       ,  :type ~ (fn [x] (:type x)) (defmethod perimeter ::rect [x] (* 2 (+ (:hx) (:wx)))) (defmethod perimeter ::triangle [x] (reduce + ((juxt :a :b :c) x))) (defmethod perimeter ::circle [x] (* 2 Math/PI (:rx))) (perimeter {:type ::rect, :h 10, :w 3}) ; -> 26 (perimeter {:type ::square, :h 10, :w 10}) ; -> 40 (perimeter {:type ::triangle, :a 3, :b 4, :c 5}) ; -> 12 (perimeter {:type ::shape}) ; -> throws IllegalArgumentException 

आप कई पदानुक्रमों की घोषणा कर सकते हैं। प्रकारों के साथ, आप एक बार (वेक्टर) कई मूल्यों पर प्रेषण कर सकते हैं। अपने स्वयं के पदानुक्रम को परिभाषित करते समय, आप कीवर्ड और जावा प्रकार भी मिला सकते हैं!

 (derive java.util.Map ::collection) (derive java.util.Collection ::collection) (derive ::tag .java.lang.Iterable) ; -> ClassCastException 

हम एक कीवर्ड से एक प्रकार का "वारिस" कर सकते हैं (लेकिन इसके विपरीत नहीं)। यह उन वर्ग समूहों को बनाने के लिए उपयोगी है जो विस्तार के लिए खुले हैं।

मल्टीमिथोड प्रणाली सरल है, लेकिन बेहद शक्तिशाली है। आमतौर पर, रोजमर्रा की जरूरतों के लिए, प्रोटोकॉल कार्यक्षमता पर्याप्त है, लेकिन जटिल और गैर-मानक स्थितियों में मल्टीमिथोड एक उत्कृष्ट समाधान हो सकता है।

सामान्य ज्ञान

भाषा का मतलब बिना आधारभूत संरचना के कुछ भी नहीं है। एक समुदाय के बिना, पुस्तकालयों, रूपरेखाओं, विभिन्न उपयोगिताओं का एक सेट। क्लोजर की एक ताकत जेवीएम प्लेटफॉर्म का उपयोग है। जावा (दोनों दिशाओं में) के साथ एकीकरण अत्यंत सरल है। यह कोई रहस्य नहीं है कि जावा के लिए बस पुस्तकालयों की एक बड़ी संख्या है (हम उनकी गुणवत्ता पर चर्चा नहीं करेंगे)। इन सभी का उपयोग सीधे क्लीजुरे से किया जा सकता है। यद्यपि देशी पुस्तकालयों की संख्या काफी बड़ी है (और लगातार बढ़ रही है)। ग्रहण और आईडीईए के

लिए प्लगइन्स सक्रिय रूप से विकसित हो रहे हैं । परियोजनाओं के निर्माण के लिए, पूरे समुदाय द्वारा उपयोग की जाने वाली लेनिंन उपयोगिता लंबे समय से वास्तविक मानक है । बनाने के लिए तरह-तरह के ढाँचे हैं WEB अनुप्रयोगों और अतुल्यकालिक सर्वर

। इम्यूनेटिव एप्लिकेशन सर्वर विकसित किया गया है ( JBoss AS7 के लिए आवरण )। इम्युटेंट रिंग (क्लोजर के लिए HTTP स्टैक), अतुल्यकालिक संदेश, वितरित कैशिंग, अनुसूचित कार्य, वितरित लेनदेन, क्लस्टरिंग और अन्य चीजों के साथ काम करने के लिए इंटरफेस प्रदान करता है। Immutant को परिनियोजित और कॉन्फ़िगर करना बेहद आसान है।

क्लोजर में वैकल्पिक कार्यान्वयन भी होते हैं, उदाहरण के लिए .Net CLR के तहत एक पोर्ट । लेकिन सच कहा जाए, तो क्लोजुरेस्क्रिप्ट सबसे अधिक ध्यान देने योग्य है, जावास्क्रिप्ट के लिए बंदरगाह। बेशक, कोई मल्टीथ्रेडिंग टूल नहीं हैं, और, परिणामस्वरूप, ट्रांसेक्शनल मेमोरी और एजेंट। लेकिन सभी अन्य भाषा सुविधाएँ उपलब्ध हैं, जिनमें लगातार संरचनाएं, मैक्रोज़, प्रोटोकॉल और मल्टीमिथोड शामिल हैं। और क्लोजुरस्क्रिप्ट और जावास्क्रिप्ट के बीच एकीकरण क्लोजर और जावा (और स्थानों में और भी बेहतर) के बीच के रूप में अच्छा और सरल है।

आगे क्या है?

और फिर सब कुछ सरल है। हमारे पास एक उपकरण है। कार्यकर्ता, विश्वसनीय। चांदी की गोली नहीं, बल्कि पर्याप्त बहुमुखी। सरल। हां, आपको इसमें महारत हासिल करने के लिए कुछ समय देना पड़ सकता है। बहुत कुछ असामान्य और अजीब लग सकता है। लेकिन यह केवल आदत की बात है, आप जल्दी से महसूस करते हैं कि किसी भाषा की संपूर्ण सुंदरता उसकी जैविकता में निहित है, व्यक्तिगत तत्वों के एक ही पूरे में नाजुक संयोजन में।

क्लोजर को जानने के लायक है। निश्चित रूप से। यहां तक ​​कि अगर यह उपकरण आपको एक या दूसरे कारण के लिए सूट नहीं करता है, तो इसमें शामिल विचार बहुत उपयोगी साबित होंगे।