🌋 📄 👩🏼‍💻 कार्यात्मक सोच: कार्यात्मक रूप से सोचना, भाग 3 🍦 🤹🏼 🏄

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

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

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

लिस्टिंग 1. स्काला पर संख्याओं का वर्गीकरण

package com.nealford.conf.ft.numberclassifier object NumberClassifier { def isFactor(number: Int, potentialFactor: Int) = number % potentialFactor == 0 def factors(number: Int) = (1 to number) filter (number % _ == 0) def sum(factors: Seq[Int]) = factors.foldLeft(0)(_ + _) def isPerfect(number: Int) = sum(factors(number)) - number == number def isAbundant(number: Int) = sum(factors(number)) - number > number def isDeficient(number: Int) = sum(factors(number)) - number < number }

भले ही आपने इस बिंदु से पहले स्काला को कभी नहीं देखा हो, इस कोड को पढ़ना आसान होना चाहिए। पहले की तरह, हमारे लिए ब्याज की दो विधियाँ factors() और sum() । factors() विधि एक दी गई संख्या से 1 की संख्या की सूची लेती है और एक मानक मान filter() पुस्तकालय विधि को लागू करती है, फ़िल्टर मानदंड के रूप में दाईं ओर कोड ब्लॉक का उपयोग करके (अन्यथा एक विधेय कहा जाता है)। कोड ब्लॉक में एक विशेष निर्माण का उपयोग किया जाता है - निहित पैरामीटर * , जो आपको पैरामीटर नाम के बजाय _ प्रतीक का उपयोग करने की अनुमति देता है जब इसकी आवश्यकता नहीं होती है। स्काला सिंटैक्स के लचीलेपन के कारण, आप ऑपरेटर की तरह filter() विधि को कॉल कर सकते हैं। निर्माण (1 to number).filter((number % _ == 0)) भी काम करेगा यदि यह आपके लिए अधिक सुविधाजनक लगता है।

sum विधि परिचित तह बाएं ऑपरेशन का उपयोग करती है ( foldLeft() को foldLeft() विधि के रूप में लागू किया गया है)। मुझे इस मामले में पैरामीटर के लिए नामों की आवश्यकता नहीं है, इसलिए मैं नाम के बजाय _ प्रतीक का उपयोग करता हूं, जो मुझे कोड ब्लॉक के लिए एक सरल और स्पष्ट सिंटैक्स देता है। foldLeft() विधि कार्यात्मक जावा लाइब्रेरी से उसी तरह की नामित विधि के समान है, जो पहले भाग में दिखाई देती है:

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

यह संख्याओं की सूची के अतिरिक्त इस तरह के ऑपरेशन के आवेदन का एक सामान्यीकृत संस्करण है: 0 से शुरू करें, पहला तत्व जोड़ें, परिणाम लें और दूसरे को इसमें जोड़ें और सूची के अंत तक जारी रखें।

इकाई परीक्षण

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

लिस्टिंग 2. स्काला पर संख्याओं के वर्गीकरण के लिए इकाई परीक्षण

 @Test def negative_perfection() { for (i <- 1 until 10000) if (Set(6, 28, 496, 8128).contains(i)) assertTrue(NumberClassifier.isPerfect(i)) else assertFalse(NumberClassifier.isPerfect(i)) }

हालांकि, आप की तरह, मैं अधिक कार्यात्मक रूप से सोचने के लिए सीखने की कोशिश कर रहा हूं, इसलिए मुझे दो कारणों से दो सूचीबद्ध करने का कोड पसंद नहीं है। सबसे पहले, वह स्वयं पुनरावृत्ति करता है, यह समस्या को हल करने के लिए एक अनिवार्य दृष्टिकोण प्रदर्शित करता है। दूसरी बात, if में दूसरी शाखा मेरे लिए वास्तव में महत्वपूर्ण नहीं है। मैं किस समस्या को हल करने की कोशिश कर रहा हूं? मुझे यह सुनिश्चित करना चाहिए कि मेरा क्लासिफायर एक अपूर्ण संख्या को पूर्ण के रूप में परिभाषित नहीं करता है। 3 की सूची इस समस्या का हल दिखाती है, लेकिन थोड़े अलग शब्दों में।

लिस्टिंग 3. स्काला पर संख्याओं के वर्गीकरण के लिए वैकल्पिक इकाई परीक्षण

 @Test def alternate_perfection() { assertEquals(List(6, 28, 496, 8128), (1 until 10000) filter (NumberClassifier.isPerfect(_))) }

3 की सूची यह सत्यापित करती है कि 1 से 100 00 तक की संख्याओं की सूची जिन्हें सही माना जाता है और ज्ञात पूर्ण संख्याओं की सूची बराबर है। कार्यात्मक सोच न केवल आपके प्रोग्रामिंग दृष्टिकोण का विस्तार करती है, बल्कि यह भी कि आप अपने कोड का परीक्षण कैसे करते हैं।

आंशिक उपयोग और करी

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

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

लिस्टिंग 4. ग्रूवी में ले जाने वाला

 def product = { x, y -> return x * y } def quadrate = product.curry(4) def octate = product.curry(8) println "4x4: ${quadrate.call(4)}" println "5x8: ${octate(5)}

लिस्टिंग 4 में, मैंने product को कोड के एक ब्लॉक के रूप में परिभाषित किया जो दो मापदंडों को लेता है। बिल्ट-इन ग्रूवी curry() विधि का उपयोग करते हुए, मैं कोड, quadrate और octate दो नए ब्लॉक बनाने के लिए मूल तत्व के रूप में product उपयोग करता octate । Groovy कोड को बहुत सरल बनाता है: आप या तो स्पष्ट रूप से कॉल () विधि से कॉल कर सकते हैं, या भाषा द्वारा प्रदान की गई सिंटैक्स चीनी का उपयोग कर सकते हैं - ब्रैकेट की एक जोड़ी।

आंशिक अनुप्रयोग एक अधिक सामान्य तकनीक है जो पुनरावृत्ति को दोहराती है, लेकिन परिणामी फ़ंक्शन को तर्कों की संख्या तक सीमित नहीं करती है। Groovy दोनों तकनीकों को लागू करने के लिए curry() विधि का उपयोग करता है, जैसा कि लिस्टिंग 5 में दिखाया गया है:

लिस्टिंग 5. करी विधि का उपयोग करके ग्रूवी में आंशिक उपयोग और करी की तुलना करना

 def volume = { h, w, l -> return h * w * l } def area = volume.curry(1) def lengthPA = volume.curry(1, 1) //partial application def lengthC = volume.curry(1).curry(1) // currying println "The volume of the 2x3x4 rectangular solid is ${volume(2, 3, 4)}" println "The area of the 3x4 rectangle is ${area(3, 4)}" println "The length of the 6 line is ${lengthPA(6)}" println "The length of the 6 line via curried function is ${lengthC(6)}"

लिस्टिंग 5 में वॉल्यूम कोड ब्लॉक एक प्रसिद्ध सूत्र का उपयोग करके बॉक्स की मात्रा की गणना करता है। मैं पहले तर्क volume को ठीक करके 1. एक area कोड ब्लॉक (जो आयत के क्षेत्र की गणना करता है) बनाता हूं। volume का उपयोग उस ब्लॉक के आधार के रूप में करता है जो लाइन की लंबाई लौटाता है, मैं आंशिक आवेदन और करी दोनों का उपयोग कर सकता हूं। lengthPA पहले दो मापदंडों को ठीक करके एक आंशिक अनुप्रयोग का उपयोग करता है। एक ही परिणाम प्राप्त करने के लिए lengthC दो बार lengthC लागू करता है। अंतर बहुत सूक्ष्म है, और परिणाम समान हैं, लेकिन यदि आप वास्तविक कार्यात्मक प्रोग्रामर के बगल में समानार्थी शब्द के रूप में करी और आंशिक उपयोग करते हैं, तो आपको संभवतः एक त्रुटि *** के बारे में बताया जाएगा।

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

लिस्टिंग 6. रचना और आंशिक आवेदन

 def composite = { f, g, x -> return f(g(x)) } def thirtyTwoer = composite.curry(quadrate, octate) println "composition of curried functions yields ${thirtyTwoer(2)}"

लिस्टिंग 6 में, मैं एक composite कोड ब्लॉक बनाता हूं जो दो कार्यों को जोड़ता है। इस ब्लॉक के साथ, मैं दो तरीकों को एक साथ जोड़ने के लिए आंशिक अनुप्रयोगों का उपयोग करके thirtyTwoer बनाता thirtyTwoer ।

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

लिस्टिंग 7. भवन की विशेषताएं

 def adder = { x, y -> return x + y } def incrementer = adder.curry(1) println "increment 7: ${incrementer(7)}"

स्केल स्वाभाविक रूप से क्यूरिंग का समर्थन करता है, जैसा कि लिस्टिंग 8 में दिखाए गए दस्तावेज़ में उदाहरण में दिखाया गया है:

लिस्टिंग 8. स्काला में ले जाना

 object CurryTest extends Application { def filter(xs: List[Int], p: Int => Boolean): List[Int] = if (xs.isEmpty) xs else if (p(xs.head)) xs.head :: filter(xs.tail, p) else filter(xs.tail, p) def dividesBy(n: Int)(x: Int) = ((x % n) == 0) val nums = List(1, 2, 3, 4, 5, 6, 7, 8) println(filter(nums, dividesBy(2))) println(filter(nums, dividesBy(3))) }

लिस्टिंग 8 में कोड प्रदर्शित करता है कि filter() विधि का उपयोग करके dividesBy() विधि को कैसे लागू किया dividesBy() । मैं filter() विधि के लिए एक अनाम फ़ंक्शन पास करता हूं, इस ब्लॉक को बनाने के लिए उपयोग किए जाने वाले मूल्य के लिए पहले dividesBy() पैरामीटर को ठीक करने के लिए करी का उपयोग करके। जब मैं एक संख्या को dividesBy() विधि से पास करता हूं, तो dividesBy() स्वचालित रूप से करी का उपयोग करके एक नया फ़ंक्शन बनाता है।

पुनरावर्तन फ़िल्टरिंग

फ़ंक्शनल प्रोग्रामिंग से जुड़ी एक अन्य अवधारणा पुनरावृत्ति है, जो (विकिपीडिया के अनुसार) "एक आत्म-समान चीज़ में कुछ दोहराने की प्रक्रिया" है। कंप्यूटर विज्ञान में, यह एक क्रिया को दोहराने की एक विधि है, जिसमें स्वयं से एक विधि को कॉल करना शामिल है (पहले यह जाँचना कि कॉल की इस श्रृंखला को पूरा करना संभव है)। अक्सर, पुनरावृत्ति हमें एक ऐसे कोड की ओर ले जाती है जो समझने में आसान है, क्योंकि समाधान वस्तुओं के सिकुड़ने वाली सूची पर एक ही ऑपरेशन करने पर आधारित है।

सूची को फ़िल्टर करने पर एक नज़र डालें। पुनरावृत्त दृष्टिकोण के साथ, मुझे एक फ़िल्टर मानदंड मिलता है और उन तत्वों को बाहर निकालता है जो मैं लूप में लूप में नहीं देखना चाहता हूं। लिस्टिंग 9 ग्रूवी पर एक साधारण फ़िल्टर कार्यान्वयन दिखाता है:

लिस्टिंग 9. ग्रूवी में फ़िल्टरिंग

 def filter(list, criteria) { def new_list = [] list.each { i -> if (criteria(i)) new_list << i } return new_list } modBy2 = { n -> n % 2 == 0 } l = filter(1..20, modBy2) println l

लिस्टिंग 9 में filter() विधि इनपुट के रूप में एक सूची और चयन मानदंड (कोड ब्लॉक) प्राप्त करती है। अंदर, यह सूची में एक और तत्व जोड़कर नई सूची में चला जाता है अगर यह मानदंडों को पूरा करता है।

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

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

निष्कर्ष

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

अगले भाग में मैं कार्यात्मक प्रोग्रामिंग की बुनियादी अवधारणाओं में से एक के बारे में अधिक बात करूंगा: अपरिवर्तनीयता।

नोट

* - ऐसा लगता है कि लेखक ने यहाँ एक गलती की। _ बंद होने में संबद्ध चर के नाम के बजाय निर्माण कार्य को अंतर्निहित पैरामीटर के बजाय बेनामी फ़ंक्शंस सिंटैक्स के लिए प्लेसहोल्डर सिंटैक्स कहा जाता है। फ़ंक्शन हस्ताक्षर में implicit कीवर्ड द्वारा एक अंतर्निहित पैरामीटर पेश किया जाता है और पूरी तरह से अलग शब्दार्थ होता है।

** - रूसी अनुवाद को औपचारिक रूप से "ऑब्जेक्ट ओरिएंटेड डिज़ाइन ट्रिक्स" कहा जाता था। मैंने इसका उपयोग पाठ में नहीं किया है, क्योंकि बहुत कम लोग इससे पुस्तक को पहचानते हैं।

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

पुनश्च अनुवाद और इस श्रृंखला को करने के विचार के साथ मदद के लिए धन्यवाद

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

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

इकाई परीक्षण

आंशिक उपयोग और करी

पुनरावर्तन फ़िल्टरिंग

निष्कर्ष

नोट

More articles: