क्या कार्यात्मक प्रोग्रामिंग समस्याओं और समाधानों के बीच 'प्रतिनिधित्वात्मक अंतर' को बढ़ाता है? [बन्द है]


18

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

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

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

मैं समवर्ती प्रोग्रामिंग के संबंध में एफपी के लाभों को समझता हूं। लेकिन क्या मुझे कुछ याद आ रहा है, या एफपी एक प्रतिनिधित्वात्मक अंतर को कम करने के बारे में नहीं है (समाधानों को समझना आसान है)?

यह पूछने का एक और तरीका: क्या एक ही वास्तविक दुनिया की समस्या को हल करने वाली 10 अलग-अलग टीमों के FP कोड में बहुत समानता है?


एब्सट्रैक्शन (कंप्यूटर विज्ञान) पर विकिपीडिया से (जोर मेरा):

फ़ंक्शनल प्रोग्रामिंग लैंग्वेज आमतौर पर फ़ंक्शंस से जुड़े एब्स्ट्रैक्ट्स को प्रदर्शित करती हैं , जैसे लैम्ब्डा एब्सट्रैक्ट्स (किसी वेरिएबल के फंक्शन में टर्म बनाना), हायर-ऑर्डर फ़ंक्शंस (पैरामीटर फ़ंक्शंस), ब्रैकेट एब्स्ट्रैक्शन (किसी वेरिएबल के फंक्शन में टर्म बनाना)।

प्रतिनिधित्वात्मक अंतर को संभावित रूप से बढ़ाया जा सकता है, क्योंकि [कुछ] वास्तविक दुनिया की समस्याओं को इस तरह के सार के साथ आसानी से मॉडलिंग नहीं किया जाता है।


एक और तरीका है कि मैं प्रतिनिधित्वात्मक अंतर को कम करता हुआ समस्या के समाधान तत्वों का पता लगा रहा हूं। 0की और 1मशीन कोड में है, वापस ट्रेस करने के लिए है, जबकि बहुत कठिन है Studentवर्ग वापस ट्रेस करने के लिए आसान है। सभी OO वर्ग समस्या वाले स्थान पर आसानी से ट्रेस नहीं करते हैं, लेकिन कई करते हैं।

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


संबंधित प्रश्न के लिए स्वीकृत उत्तर क्या यूएमएल को एक कार्यात्मक कार्यक्रम के लिए इस्तेमाल किया जा सकता है? - कहते हैं, "कार्यात्मक प्रोग्रामर के पास आरेखों का बहुत अधिक उपयोग नहीं होता है।" अगर यह यूएमएल है, तो मुझे वास्तव में परवाह नहीं है, लेकिन यह मुझे एफपी अमूर्तता को समझने / संवाद करने में आसान बनाता है, अगर कोई आरेख नहीं हैं जो व्यापक रूप से उपयोग किए जाते हैं (यह उत्तर सही है)। फिर से, एफपी उपयोग / समझ का मेरा स्तर तुच्छ है, इसलिए मुझे लगता है कि सरल एफपी कार्यक्रमों पर आरेख की कोई आवश्यकता नहीं है।

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


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

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

  • मौजूदा कार्यात्मक कार्यक्रम एक पैमाने के होते हैं जिसमें डिजाइन की आवश्यकता नहीं होती है। कई कार्यात्मक कार्यक्रम छोटे हैं, लेकिन अन्य, जैसे ग्लासगो हास्केल कंपाइलर, पर्याप्त हैं।

  • कार्यात्मक कार्यक्रम सीधे आवेदन डोमेन को मॉडल करते हैं, इस प्रकार डिजाइन अप्रासंगिक प्रदान करते हैं। जब तक कार्यात्मक भाषाएं विभिन्न प्रकार के शक्तिशाली सार प्रदान करती हैं, यह तर्क करना मुश्किल है कि ये वास्तविक दुनिया को मॉडल करने के लिए आवश्यक सभी और केवल सार प्रदान करते हैं।

  • कार्यात्मक कार्यक्रमों को प्रोटोटाइप की एक विकसित श्रृंखला के रूप में बनाया गया है।

में पीएचडी थीसिस ऊपर उद्धृत , विश्लेषण और डिजाइन के तरीके (ADM) के उपयोग के लाभ मानदंड से स्वतंत्र दिए गए हैं। लेकिन एक तर्क यह दिया जाता है कि एडीएम को कार्यान्वयन प्रतिमान के साथ संरेखित करना चाहिए। यही है, OOADM OO प्रोग्रामिंग के लिए सबसे अच्छा काम करता है और इसे FP जैसे किसी अन्य प्रतिमान पर लागू नहीं किया जाता है। यहाँ एक महान उद्धरण है जो मुझे लगता है कि मैं जो निरूपण करता हूं उसे मैं प्रतिनिधित्वात्मक अंतर कहता हूं:

कोई भी तर्क दे सकता है जिसके संबंध में प्रतिमान सॉफ्टवेयर विकास के लिए सबसे अच्छा समर्थन प्रदान करता है, लेकिन सबसे अधिक प्राकृतिक, कुशल और प्रभावी विकास पैकेज प्राप्त करता है जब कोई समस्या के विवरण और कार्यान्वयन और वितरण के माध्यम से एक एकल प्रतिमान के भीतर रहता है।

यहाँ FAD द्वारा प्रस्तावित आरेखों का सेट दिया गया है:

  • फ़ंक्शन निर्भरता आरेख जो इसके कार्यान्वयन में उपयोग करने वालों के साथ एक फ़ंक्शन प्रस्तुत करते हैं;
  • प्रकार निर्भरता आरेख जो प्रकारों के लिए एक ही सेवा प्रदान करता है; तथा,
  • मॉड्यूल निर्भरता आरेख जो सिस्टम के मॉड्यूल वास्तुकला के विचार प्रस्तुत करते हैं।

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

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


1
टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।
maple_shaft

जवाबों:


20

मूल डेटा बहुत अधिक किसी भी प्रतिमान में समान है। आप एक है Student, एक Course, आदि जा रहे हैं कि क्या यह एक वस्तु, एक संरचना, एक रिकॉर्ड, या जो कुछ भी है। OOP के साथ अंतर यह नहीं है कि डेटा कैसे संरचित है, यह कैसे कार्य संरचित है।

मैं वास्तव में कार्यात्मक कार्यक्रमों को अधिक बारीकी से मिलाता हूं कि मैं किसी समस्या के बारे में कैसे सोचता हूं। उदाहरण के लिए, अगले सेमेस्टर के लिए एक छात्र के कार्यक्रम की योजना बनाने के लिए, आप उन चीजों के बारे में सोचते हैं, जो एक छात्र द्वारा पूरा किए गए पाठ्यक्रमों की सूचियों के बारे में है, एक छात्र की डिग्री कार्यक्रम में पाठ्यक्रम, पाठ्यक्रम इस सेमेस्टर की पेशकश करते हैं, एक छात्र ने पाठ्यक्रमों के लिए आवश्यक शर्तें पूरी की हैं, समय के साथ पाठ्यक्रम 'टी संघर्ष, आदि।

अचानक, यह इतना स्पष्ट नहीं है कि किस वर्ग को इन सभी सूचियों को बनाना और संग्रहीत करना चाहिए। इससे भी कम जब आपके पास इन सूचियों के जटिल संयोजन होते हैं। हालाँकि, आपको एक वर्ग चुनना होगा

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

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


5
मेरे अनुभव में @BenAaronson समस्या यह है कि तब किसी छात्र से संबंधित कोई भी कार्य छात्र वर्ग में जोड़ा जाता है और उसकी जिम्मेदारियां बढ़ती हैं और तब तक बढ़ती हैं जब तक आपको StudentCourseFiltererप्रबंधनीय चीजों को रखने के लिए परिचय की आवश्यकता नहीं होती
AlexFoxGill

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

3
@ देखें एरिक मीजेर की "'ज्यादातर फंक्शनल' प्रोग्रामिंग काम नहीं करती है" , जो हाइब्रिड दृष्टिकोण के खिलाफ और पूर्ण "कट्टरपंथी" एफपी के लिए जाने का तर्क देता है।
एंड्रेस एफ।

4
@ जब आप जिस लोकप्रियता का वर्णन करते हैं, मुझे डर है, इतिहास की एक दुर्घटना। मैं काम पर स्काला का उपयोग करता हूं, और यह एफपी और ओओपी को मिलाने के तरीके के कारण एक जटिल जानवर है। हास्केल की तरह एक सच्ची एफपी भाषा पर स्विच करने से ताजी हवा की सांस महसूस होती है - और मैं अकादमिक दृष्टिकोण से भी बात नहीं कर रहा हूँ!
एंड्रेस एफ।

3
@ क्या मैं यह नहीं बता सकता कि उन कार्यों में से क्या करते हैं। हालांकि, मैं आपको बता सकता हूं कि क्या एफपी में पहला फ़ंक्शन एक सॉर्ट या फ़िल्टर था, इसे फ़िल्टर या सॉर्ट नाम दिया जाएगा , न कि func(जैसे आपने इसे नाम दिया है IFilter, आदि)। सामान्य तौर पर, एफपी में आप इसे नाम था funcया fजब या तो sortया filterएक मान्य विकल्प है! उदाहरण के लिए, एक उच्च-क्रम फ़ंक्शन लिखते समय जो funcएक पैरामीटर के रूप में लेता है ।
एंड्रेस एफ।

10

जब मैंने अपने जावा वर्ग को वर्षों पहले लिया था, तो हमें उम्मीद थी कि हम पूरी कक्षा को अपने समाधान दिखाएंगे, इसलिए मुझे यह देखने को मिला कि लोग कैसे सोचते हैं; वे तार्किक रूप से समस्याओं को कैसे हल करते हैं। मुझे पूरी तरह से तीन या चार सामान्य समाधानों के क्लस्टर के समाधान की उम्मीद थी। इसके बजाय, मैंने देखा कि 30 छात्रों ने समस्या को 30 पूरी तरह से अलग तरीके से हल किया।

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

कार्यात्मक प्रोग्रामिंग को रेखांकित करने वाली तकनीकी भाषा गणित है । तदनुसार, कार्यात्मक प्रोग्रामिंग का उपयोग करके हल करने के लिए जो समस्याएं सबसे उपयुक्त हैं, वे अनिवार्य रूप से गणित की समस्याएं हैं। गणित के अनुसार, मैं उस तरह के गणित की बात नहीं कर रहा हूँ जिसे आप व्यापार समाधानों में देखेंगे, जैसे कि जोड़ और घटाव। बल्कि, मैं गणित के उस प्रकार के बारे में बात कर रहा हूँ जिसे आप Math Overflow पर देख सकते हैं, या जिस तरह का गणित आप Orbitz के सर्च इंजन में देखेंगे (यह लिस्प में लिखा गया है)।

इस अभिविन्यास में कार्यात्मक प्रोग्रामर के लिए कुछ महत्वपूर्ण प्रभाव हैं, जो वास्तविक दुनिया की प्रोग्रामिंग समस्याओं को हल करने की कोशिश कर रहे हैं:

  1. कार्यात्मक प्रोग्रामिंग अनिवार्य से अधिक घोषणात्मक है; यह मुख्य रूप से कंप्यूटर को यह बताने के लिए चिंतित है कि क्या करना है, कैसे नहीं।

  2. ऑब्जेक्ट-ओरिएंटेड प्रोग्राम अक्सर टॉप-डाउन से बनाए जाते हैं। एक वर्ग डिज़ाइन बनाया जाता है, और विवरण भरे जाते हैं। कार्यात्मक कार्यक्रम अक्सर नीचे-ऊपर से बनाए जाते हैं, छोटे, विस्तृत कार्यों से शुरू होते हैं जिन्हें उच्च-स्तरीय कार्यों में जोड़ा जाता है।

  3. कार्यात्मक प्रोग्रामिंग में जटिल तर्क के प्रोटोटाइप के लिए फायदे हो सकते हैं, लचीले कार्यक्रमों का निर्माण कर सकते हैं जो व्यवस्थित रूप से विकसित और विकसित हो सकते हैं, और सॉफ्टवेयर का निर्माण कर सकते हैं जहां प्रारंभिक डिजाइन अस्पष्ट है।

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

  5. क्योंकि सभी व्यावहारिक सॉफ़्टवेयर साइड-इफेक्ट्स (I / O) का उत्पादन करते हैं, विशुद्ध रूप से कार्यात्मक प्रोग्रामिंग भाषाओं को गणितीय रूप से शुद्ध (मोनैड्स) रहते हुए उन दुष्प्रभावों का उत्पादन करने के लिए एक तंत्र की आवश्यकता होती है।

  6. उनके गणितीय स्वभाव के कारण कार्यात्मक कार्यक्रम अधिक आसानी से साबित हो सकते हैं। हास्केल के प्रकार प्रणाली को संकलन के समय ऐसी चीजें मिल सकती हैं जो अधिकांश OO भाषाएँ नहीं कर सकती हैं।

और इसी तरह। कंप्यूटिंग में कई चीजों की तरह, ऑब्जेक्ट-ओरिएंटेड भाषाओं और कार्यात्मक भाषाओं में अलग-अलग ट्रेडऑफ़ हैं।

कुछ आधुनिक OO भाषाओं ने कुछ उपयोगी कार्यात्मक प्रोग्रामिंग अवधारणाओं को अपनाया है, ताकि आप दोनों दुनिया के सर्वश्रेष्ठ हो सकें। Linq, और भाषा सुविधाएँ जो इसे समर्थन करने के लिए जोड़ी गई थीं, इसका एक अच्छा उदाहरण है।


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

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

5
+1, लेकिन मैं अंक 2 और 4 पर नहीं बेचा गया हूं। मैंने बहुत सारे हास्केल ट्यूटोरियल और ब्लॉग पोस्ट देखे हैं जो एक समस्या को नीचे-ऊपर करके शुरू करते हैं, सभी प्रकार और संचालन को परिभाषित करते हुए यह देखने के लिए कि यह सब एक साथ कैसे फिट होता है हर मूल्य और फ़ंक्शन की परिभाषा को अपरिभाषित (अच्छी तरह से, एक अपवाद फेंकने के लिए परिभाषित) छोड़कर। यह मुझे लगता है कि हास्केल प्रोग्रामर समस्या को अधिक अच्छी तरह से मॉडल करते हैं, क्योंकि वे शब्दार्थ के लिए तुच्छ प्रकार जोड़ने के लिए अधिक इच्छुक हैं - जैसे SafeStringएचटीएमएल से बचने वाले तार का प्रतिनिधित्व करने के लिए एक प्रकार जोड़ना - और आमतौर पर अधिक ट्रैक प्रभाव।
डोभाल

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

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

7

मैं एक पहलू पर जोर देना चाहूंगा जो मुझे महत्वपूर्ण लगता है और जो अन्य उत्तरों में शामिल नहीं किया गया है।

सबसे पहले, मुझे लगता है कि प्रोग्रामर के दिमाग में उनकी पृष्ठभूमि और उन अवधारणाओं के अनुसार समस्याओं और समाधानों के बीच प्रतिनिधित्वात्मक अंतर अधिक हो सकता है, जिनसे वे परिचित हैं।

ओओपी और एफपी दो अलग-अलग दृष्टिकोणों से डेटा और संचालन को देखते हैं और अलग-अलग ट्रेडऑफ़ प्रदान करते हैं, जैसा कि रॉबर्ट हार्वे ने पहले ही बताया है।

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

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

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

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

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

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

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


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

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

1
@ जिओर्जियो शायद मुझे इस हिस्से से कोई मतलब नहीं मिल रहा है: "नए स्वरूपों को जोड़ना अधिक शामिल है: आपको उन सभी कार्यों को बदलने की आवश्यकता है जिन्हें आपने पहले ही लागू किया है।"
हे

2
@ हे जियोर्जियो संभावित रूप से तथाकथित अभिव्यक्ति समस्या का जिक्र कर रहा है । "नए स्वरूपों को जोड़ने" का अर्थ है "नए रचनाकारों (उर्फ 'मामलों') को एक डेटाटाइप में जोड़ना"।
एंड्रेस एफ।

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

5

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

हास्केल में इन प्रकारों के साथ आप जिस तरह से काम करते हैं वह अक्सर ओओ के रास्ते से अलग नहीं होता है। हास्केल में मैं कहता हूं

  null xs
  length xs

और जावा में आप कहते हैं

  xs.isEmpty
  xs.length

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

हास्केल में, अगर मेरे पास है - पूर्णांक का एक संग्रह - इससे कोई फर्क नहीं पड़ता कि संग्रह एक सूची है या सेट या इस कोड के लिए

  fmap (* 2) is

सभी तत्वों को दोगुना करने के साथ एक संग्रह लौटाएगा। बहुरूपता का अर्थ है कि विशिष्ट प्रकार के लिए उपयुक्त मानचित्र कार्य कहा जाएगा।

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

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


तथ्य की बात के रूप में, आप जावा / सी # में टाइप कक्षाओं का उपयोग कर सकते हैं; आप केवल स्पष्ट रूप से फ़ंक्शन के शब्दकोश को पास करते हैं, इसके बजाय कंपाइलर टाइप के आधार पर सही अनुमान लगाते हैं।
डोभाल

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

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

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

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

4

एफपी वास्तव में प्रतिनिधित्वात्मक अंतर में कमी के लिए प्रयास करता है:

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

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

* हाँ, कई ओओपी भाषाओं में आप मानक ऑपरेटरों को ओवरराइड कर सकते हैं, लेकिन हास्केल में, आप नए को परिभाषित कर सकते हैं!

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


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

3
@Fuhrmanator एक ग्राहक अभी भी चाहे आप OOP और FP का उपयोग करें, एक-लाइन उपयोगकर्ता कहानियां और व्यावसायिक नियम लिख सकते हैं । मुझे उम्मीद नहीं है कि ग्राहक उच्च-क्रम के कार्यों को समझने की अपेक्षा करते हैं, जितना मैं उनसे विरासत, रचना या इंटरफेस को समझने की अपेक्षा करता हूं।
एंड्रेस एफ।

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

@Fuhrmanator यह उतना उच्च-स्तरीय नहीं हो सकता है जितना आप देख रहे हैं, लेकिन कार्यात्मक तकनीकों का उपयोग करके डिज़ाइन प्रक्रिया में कुछ जानकारी देनी चाहिए: प्रकारों के साथ डिज़ाइन करना । मैं उस साइट को सामान्य रूप से ब्राउज़ करने की सलाह दूंगा क्योंकि इसमें कुछ उत्कृष्ट लेख हैं।
पौल २

@Fumanmanator इस सोच को भी कार्यात्मक श्रृंखला है
पॉल

3

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

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

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


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

if you know what input a function takes and what output it produces, why should it matter which data structure it belongs too?यह सामंजस्य की तरह लगता है, जो किसी भी मॉड्यूलर प्रणाली के लिए महत्वपूर्ण है। मैं तर्क दूंगा कि किसी समारोह को खोजने के लिए न जाने कहां से समाधान को समझना कठिन हो जाएगा, जो कि उच्च प्रतिनिधित्व वाली खाई के कारण है। बहुत सारे OO सिस्टम में यह समस्या है, लेकिन यह खराब डिज़ाइन (कम सामंजस्य) के कारण है। फिर, नाम स्थान का मुद्दा एफपी में मेरी विशेषज्ञता से बाहर है, इसलिए शायद यह उतना बुरा नहीं है जितना लगता है।
फुहारमेनटर

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

1
@Fuhrmanator, "यह बहुत अच्छा लगता है सामंजस्य" के बाद, मैंने आपसे तार्किक रूप से निष्कर्ष निकालने की अपेक्षा की होगी कि FP भाषाएँ आपको उच्च सामंजस्य के साथ प्रोग्राम लिखने देती हैं लेकिन आपने मुझे सर्पोट कर दिया है। :-) मुझे लगता है कि आपको एक एफपी भाषा चुननी चाहिए, इसे सीखें और अपने लिए फैसला करें। अगर मैं आप थे, तो मैं हास्केल के साथ शुरू करने का सुझाव दूंगा क्योंकि यह काफी शुद्ध है और इसलिए आपको अनिवार्य शैली में कोड लिखने की अनुमति नहीं देगा। एर्लैंग और कुछ लिस्प भी अच्छे विकल्प हैं, लेकिन वे अन्य प्रोग्रामिंग शैलियों में मिश्रण करते हैं। Scala और Clojure, IMO, शुरू करने के लिए काफी जटिल हैं।
मकलकोव २ m'१५
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.