👨🏾‍🚒 🔌 🏟️ कार्यात्मक सोच: कार्यात्मक रूप से सोचना, भाग 2 👩🏾‍💼 ✏️ 🐈

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

प्रथम श्रेणी के कार्य और नियंत्रण

फ़ंक्शनल जावा लाइब्रेरी का उपयोग करते हुए, पिछली बार जब मैंने कार्यात्मक शैली में लिखे गए isFactor () और factorOf () विधियों के साथ नंबर क्लासिफायर के कार्यान्वयन का प्रदर्शन किया था, जैसा कि लिस्टिंग 1 में दिखाया गया है:

लिस्टिंग 1. नंबर क्लासिफायर के कार्यात्मक संस्करण

import fj.F; import fj.data.List; import static fj.data.List.range; import static fj.function.Integers.add; import static java.lang.Math.round; import static java.lang.Math.sqrt; public class FNumberClassifier { public boolean isFactor(int number, int potential_factor) { return number % potential_factor == 0; } public List<Integer> factorsOf(final int number) { return range(1, number+1).filter(new F<Integer, Boolean>() { public Boolean f(final Integer i) { return number % i == 0; } }); } public int sum(List<Integer> factors) { return factors.foldLeft(fj.function.Integers.add, 0); } public boolean isPerfect(int number) { return sum(factorsOf(number)) - number == number; } public boolean isAbundant(int number) { return sum(factorsOf(number)) - number > number; } public boolean isDeficiend(int number) { return sum(factorsOf(number)) - number < number; } }

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

कार्यात्मक जावा फ्रेमवर्क के साथ भी, जावा में इस शैली में प्रोग्रामिंग अजीब लग रहा है क्योंकि भाषा में वास्तव में आवश्यक वाक्यविन्यास और निर्माण नहीं है। इसके लिए डिज़ाइन की गई भाषाओं में कार्यात्मक दृष्टिकोण कैसे लागू किया जाता है?

क्लोजर में क्लासिफायर

क्लोजर एक कार्यात्मक लिस्प है जिसे जेवीएम के लिए डिज़ाइन किया गया है। क्लोजर में लिखित संख्याओं के वर्गीकरण को देखें - सूची 2

लिस्टिंग 2. संख्या वर्गीकरण के क्लोजर कार्यान्वयन

 (ns nealford.perfectnumbers) (use '[clojure.contrib.import-static :only (import-static)]) (import-static java.lang.Math sqrt) (defn is-factor? [factor number] (= 0 (rem number factor))) (defn factors [number] (set (for [n (range 1 (inc number)) :when (is-factor? n number)] n))) (defn sum-factors [number] (reduce + (factors number))) (defn perfect? [number] (= number (- (sum-factors number) number))) (defn abundant? [number] (< number (- (sum-factors number) number))) (defn deficient? [number] (> number (- (sum-factors number) number)))

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

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

factors() विधि आपको यादृच्छिक वर्णों का एक सेट लग सकती है। लेकिन इसे ठीक से समझा जा सकता है यदि आपने एक बार सूची की समझ को देखा, जो क्लोजर की कई शक्तिशाली विशेषताओं में से एक है। पहले की तरह, कारक विधि को समझने का सबसे आसान तरीका भीतर से है। उस भाषाई शब्दावली से भ्रमित न हों जो आपको स्तूप में ले जाती है। लूप में कीवर्ड का मतलब यह नहीं है कि - लूप के लिए। इसे सभी फ़िल्टरिंग और ट्रांसफ़ॉर्मिंग संरचनाओं के पूर्वज के रूप में सोचें। इस मामले में, मैं इसे is-factor? विधेय का उपयोग करके 1 से संख्या (संख्या + 1) की संख्या को फ़िल्टर करने के लिए कहता हूं is-factor? वह संख्या जो शर्त को पूरा करती है। इस ऑपरेशन का आउटपुट संख्याओं की एक सूची है जो मेरे मानदंडों को पूरा करती है, जिसे मैं पुनरावृत्ति को हटाने के लिए एक सेट में बदल देता हूं।

आपको सीखने में प्रारंभिक कठिनाइयों के बावजूद, उनकी बारीकियों और विशेषताओं की समझ के साथ कार्यात्मक भाषाओं से बहुत सारी शांत चीजें मिलती हैं।

अनुकूलन

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

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

अनुकूलन जो जावा संस्करण में करना आसान था, कार्यात्मक जावा में असंभव लगता है क्योंकि मैं सीधे पुनरावृत्ति को नियंत्रित नहीं करता हूं। हालांकि, कार्यात्मक सोच के मार्ग को हमें इस प्रकार के नियंत्रण को छोड़ने की आवश्यकता है, जिससे दूसरों को नियंत्रण करने की अनुमति मिलती है।

मैं एक कार्यात्मक शैली में मूल समस्या का सुधार कर सकता हूं: एक दिए गए नंबर से 1 से सभी विभाजकों को फ़िल्टर करें, केवल उन लोगों को छोड़ दें जो isFactor विधेय को संतुष्ट करते हैं। यह लिस्टिंग 3 में किया गया है:

लिस्टिंग 3. TheFactor () विधि

 public List<Integer> factorsOf(final int number) { return range(1, number+1).filter(new F<Integer, Boolean>() { public Boolean f(final Integer i) { return number % i == 0; } }); }

अपने लालित्य के बावजूद, सूची 3 में कोड बहुत कुशल नहीं है क्योंकि यह हर नंबर की जांच करता है। हालाँकि, अनुकूलन को समझने में (1 से वर्गमूल में जोड़े में डिवाइडर इकट्ठा करना), मैं समस्या का सुधार कर सकता हूं:

किसी संख्या के वर्गमूल को 1 से सभी संख्याओं को फ़िल्टर करें।
दिए गए संख्या को इनमें से प्रत्येक विभक्त द्वारा विभाजित युग्मक प्राप्त करने के लिए विभाजित करें और इसे विभक्तों की सूची में जोड़ें।

इस एल्गोरिथ्म के साथ, मैं फंक्शनल जावा लाइब्रेरी का उपयोग करके फैक्ट्सऑफ () पद्धति का एक अनुकूलित संस्करण लिख सकता हूं, जैसा कि लिस्टिंग 4 में दिखाया गया है:

लिस्टिंग 4. अनुकूलित कारकों-खोज विधि

 public List<Integer> factorsOfOptimzied(final int number) { List<Integer> factors = range(1, (int) round(sqrt(number)+1)) .filter(new F<Integer, Boolean>() { public Boolean f(final Integer i) { return number % i == 0; }}); return factors.append(factors.map(new F<Integer, Integer>() { public Integer f(final Integer i) { return number / i; }})) .nub(); }

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

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

कोड के ऊपर जो मैंने उद्धृत किया, ब्लॉक का सिंटैक्स नेत्रहीन रूप से हावी है, जो कोड के छद्म ब्लॉक के रूप में सामान्यीकरण और अनाम नेस्टेड वर्गों का उपयोग करता है। क्लोजर कार्यात्मक भाषाओं की सबसे आम विशेषताओं में से एक हैं। एक कार्यात्मक दुनिया में उन्हें क्या उपयोगी बनाता है?

बंदों में ऐसा क्या खास है?

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

5 की सूची एक उदाहरण दिखाती है जो क्लोजर को विशेष बनाता है। यह ग्रूवी में लिखा गया है, जो सीधे बंद होने का समर्थन करता है।

लिस्टिंग 5. ग्रूवी कोड चित्रण क्लोजर

 def makeCounter() { def very_local_variable = 0 return { return very_local_variable += 1 } } c1 = makeCounter() c1() c1() c1() c2 = makeCounter() println "C1 = ${c1()}, C2 = ${c2()}" // output: C1 = 4, C2 = 1

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

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

जावा में कार्यान्वित इस व्यवहार का निकटतम दृष्टिकोण सूची 6 में दिखाया गया है:

लिस्टिंग 6. जावा में मेक एनकाउंटर

 public class Counter { private int varField; public Counter(int var) { varField = var; } public static Counter makeCounter() { return new Counter(0); } public int execute() { return ++varField; } }

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

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

निष्कर्ष

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

अगले अंक में, मैं जावा और इसके करीबी रिश्तेदारों के साथ करी और आंशिक विधि आवेदन के वर्णन के साथ कार्यात्मक निर्माण के माध्यम से अपनी यात्रा जारी रखूंगा।

नोट

* - यहाँ लेखक को अकादमिक शब्दावली का अत्यधिक ज्ञान है। हम एक लंबोदर अभिव्यक्ति में मुफ्त चर के बारे में बात कर रहे हैं। एसएफपी में लेख से विभिन्न कार्यान्वयनों में बंद होने के व्यवहार के बारे में एक अच्छा अंतर्ज्ञान प्राप्त किया जा सकता है। मुक्त और संबंधित चर की एक स्पष्ट रूप से स्पष्ट औपचारिक परिभाषा विकिपीडिया लेख में दी गई है।

पुनश्च अनुवाद के साथ मदद के लिए धन्यवाद CheatEx ।

कार्यात्मक सोच: कार्यात्मक रूप से सोचना, भाग 2

प्रथम श्रेणी के कार्य और नियंत्रण

क्लोजर में क्लासिफायर

अनुकूलन

बंदों में ऐसा क्या खास है?

निष्कर्ष

नोट

More articles: