💩 🍉 👨🏿‍⚖️ कार्यात्मक सोच: कार्यात्मक रूप से सोचना, भाग 1 📂 🦂 👨🏻‍🌾

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

चेनसा के स्थान पर कार्यात्मक प्रोग्रामिंग डालते हुए, यह कहानी आपको परिचित लग सकती है। समस्या एक पूरी तरह से नई प्रोग्रामिंग प्रतिमान है - एक नई भाषा नहीं सीखना। इसके अलावा, भाषा का वाक्य विन्यास केवल विवरण है। पूरी सूक्ष्मता को अलग तरीके से सोचना सीखना है। यही कारण है कि मैं यहाँ समाप्त हुआ - एक चेनसॉ इंजन और एक "कार्यात्मक" प्रोग्रामर।

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

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

संख्या वर्गीकरण

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

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

इंपीरियल नंबर क्लासिफायरियर

उपरोक्त आवश्यकताओं को पूरा करने वाला एक अनिवार्य वर्ग नीचे प्रस्तुत किया गया है:

लिस्टिंग 1. NumberClassifier, समस्या का अनिवार्य समाधान

public class Classifier6 { private Set<Integer> _factors; private int _number; public Classifier6(int number) { if (number < 1) throw new InvalidNumberException( "Can't classify negative numbers"); _number = number; _factors = new HashSet<Integer>>(); _factors.add(1); _factors.add(_number); } private boolean isFactor(int factor) { return _number % factor == 0; } public Set<Integer> getFactors() { return _factors; } private void calculateFactors() { for (int i = 1; i <= sqrt(_number) + 1; i++) if (isFactor(i)) addFactor(i); } private void addFactor(int factor) { _factors.add(factor); _factors.add(_number / factor); } private int sumOfFactors() { calculateFactors(); int sum = 0; for (int i : _factors) sum += i; return sum; } public boolean isPerfect() { return sumOfFactors() - _number == _number; } public boolean isAbundant() { return sumOfFactors() - _number > _number; } public boolean isDeficient() { return sumOfFactors() - _number < _number; } public static boolean isPerfect(int number) { return new Classifier6(number).isPerfect(); } }

इस कोड में ध्यान देने योग्य कुछ बातें:

यूनिट परीक्षणों के एक बड़े सेट की आवश्यकता है (आंशिक रूप से इस तथ्य के कारण कि मैंने इसे TDD पहलू में चर्चा के लिए लिखा है)
वर्ग में संबंधित विधियों की एक बड़ी संख्या होती है, जो इस रूप में टीडीडी में उपयोग के लिए एक दुष्प्रभाव है
अंतर्निहित परिकलनकर्ता () प्रदर्शन अनुकूलन की विधि। इस वर्ग का सार उन्हें एक साथ जोड़ने और अंततः उन्हें वर्गीकृत करने के लिए भाजक का संग्रह है। दिव्यांगों को हमेशा जोड़ा जा सकता है। उदाहरण के लिए, यदि इनपुट संख्या 16 है, तो जब मैं भाजक 2 का निर्धारण करता हूं, तो मैं भी 2 * 8 = 16 के बाद से 8 का उपयोग करता हूं। यदि मैं विभाजकों को जोड़ियों में इकट्ठा करता हूं, तो मुझे उन पर जांच करने की आवश्यकता है, जो प्रश्न में संख्याओं के वर्गमूल को बनाते हैं, जो कि वास्तव में कैलकुलेटफैक्टर्स () विधि करता है।

(थोड़ा और अधिक) कार्यात्मक क्लासिफायरियर

उसी TDD तकनीकों का उपयोग करते हुए, मैंने क्लासिफायर का एक वैकल्पिक संस्करण बनाया, जिसे आप लिस्टिंग 2 में देख सकते हैं:

लिस्टिंग 2. थोड़ा और अधिक कार्यात्मक संख्या वर्गीकारक

 public class NumberClassifier { static public boolean isFactor(int number, int potential_factor) { return number % potential_factor == 0; } static public Set<Integer> factors(int number) { HashSet<Integer> factors = new HashSet<Integer>(); for (int i = 1; i <= sqrt(number); i++) if (isFactor(number, i)) { factors.add(i); factors.add(number / i); } return factors; } static public int sum(Set<Integer> factors) { Iterator it = factors.iterator(); int sum = 0; while (it.hasNext()) sum += (Integer) it.next(); return sum; } static public boolean isPerfect(int number) { return sum(factors(number)) - number == number; } static public boolean isAbundant(int number) { return sum(factors(number)) - number > number; } static public boolean isDeficient(int number) { return sum(factors(number)) - number < number; } }

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

कार्य

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

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

उच्चतर कार्य

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

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

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

लिस्टिंग 3. संभावित पुन: प्रयोज्य कोड टेम्पलेट

 public void addOrderFrom(ShoppingCart cart, String userName, Order order) throws Exception { setupDataInfrastructure(); try { add(order, userKeyBasedOn(userName)); addLineItemsFrom(cart, order.getOrderKey()); completeTransaction(); } catch (Exception condition) { rollbackTransaction(); throw condition; } finally { cleanUp(); } }

लिस्टिंग 3 में कोड में आरंभीकरण होता है, कुछ काम करता है, लेनदेन को पूरा करता है यदि यह सफल होता है, अन्यथा यह वापस रोल करता है और संसाधनों को जारी करता है। बेशक, इस कोड के टेम्पलेट भाग का पुन: उपयोग किया जा सकता है, और हम, एक नियम के रूप में, इसे एक संरचना बनाकर OOP में लागू करते हैं। हमारे मामले में, मैं 2 " गैंग ऑफ़ फोर डिज़ाइन पैटर्न " पैटर्न: कम्बाइन मेथड एंड कमांड पैटर्न को मिलाऊँगा। टेम्प्लेट विधि यह मानती है कि मुझे बच्चे के वर्गों में एल्गोरिथ्म के कार्यान्वयन को छोड़कर वंशानुक्रम पदानुक्रम के कोड को दोहराने की आवश्यकता है। "कमांड" पैटर्न एक वर्ग में अच्छी तरह से ज्ञात निष्पादन शब्दार्थ के साथ व्यवहार को घेरने की अनुमति देता है। सूची 4 इन दो पैटर्न को कोड 3 में कोड में लागू करने का परिणाम दिखाता है:

लिस्टिंग 4. खंडित आदेश कोड

 public void wrapInTransaction(Command c) throws Exception { setupDataInfrastructure(); try { c.execute(); completeTransaction(); } catch (Exception condition) { rollbackTransaction(); throw condition; } finally { cleanUp(); } } public void addOrderFrom(final ShoppingCart cart, final String userName, final Order order) throws Exception { wrapInTransaction(new Command() { public void execute() { add(order, userKeyBasedOn(userName)); addLineItemsFrom(cart, order.getOrderKey()); } }); }

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

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

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

लिस्टिंग 5. कमांड वर्गों के बजाय ग्रूवी क्लोजर का उपयोग करना

 def wrapInTransaction(command) { setupDataInfrastructure() try { command() completeTransaction() } catch (Exception ex) { rollbackTransaction() throw ex } finally { cleanUp() } } def addOrderFrom(cart, userName, order) { wrapInTransaction { add order, userKeyBasedOn(userName) addLineItemsFrom cart, order.getOrderKey() } }

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

प्रथम श्रेणी के कार्य

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

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

लिस्टिंग 6. कार्यात्मक संख्या वर्गीकारक

 public class FNumberClassifier { public boolean isFactor(int number, int potential_factor) { return number % potential_factor == 0; } public List<Integer> factors(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(factors(number)) - number == number; } public boolean isAbundant(int number) { return sum(factors(number)) - number > number; } public boolean isDeficiend(int number) { return sum(factors(number)) - number < number; } }

लिस्टिंग 6 और 2 के बीच मुख्य अंतर दो तरीके हैं: योग () और कारक () । sum () Functional Java में List class के संबंध में foldLeft () पद्धति का लाभ उठाती है । इस विशिष्ट प्रकार की सूची हेरफेर को कैटमोर्फिज्म कहा जाता है, जो सूची तह के लिए एक सामान्यीकरण है। इस मामले में, "सूची को मोड़ना" का अर्थ है:

प्रारंभिक मान लें, निर्दिष्ट ऑपरेशन को सूची के पहले तत्व के साथ जोड़ा गया
परिणाम प्राप्त करें और अगले तत्व के साथ एक ही ऑपरेशन को लागू करें
सूची के अंत तक पहुंचने तक दोहराएं।

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

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

निष्कर्ष

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

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

पुनश्च अनुवाद की समीक्षा के लिए CheatEx को बहुत धन्यवाद। सबसे अधिक संभावना है, जारी रखने के लिए ...

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