क्या कार्यात्मक प्रोग्रामिंग "मॉड्यूल में डिकम्पोजिंग सिस्टम में उपयोग किए जाने वाले मानदंड पर" (डेटा छुपाकर) से प्राप्त लाभों को अनदेखा करता है?


27

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

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

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

  1. पहले मैं जानना चाहता हूं कि क्या मेरा आकलन सही है। क्या एफपी प्रतिमान और यह लेख दार्शनिक रूप से असहमत है?
  2. वे असहमत मानते हुए, एफपी डेटा की कमी के लिए "क्षतिपूर्ति" कैसे करता है? शायद वे डेटा छिपाने का त्याग करते हैं, लेकिन एक्स, वाई और जेड हासिल करते हैं। मैं इसका कारण जानना चाहूंगा कि एक्स, वाई और जेड को डेटा छिपाने की तुलना में अधिक फायदेमंद क्यों माना जाता है।
  3. या, यह मानते हुए कि वे असहमत हैं, शायद एफपी को लगता है कि डेटा छिपाना बुरा है। यदि हां, तो यह क्यों लगता है कि डेटा छिपाना बुरा है?
  4. मान लें कि वे सहमत हैं, तो मैं जानना चाहूंगा कि डेटा छिपाने का FPs कार्यान्वयन क्या है। OOP में यह देखना स्पष्ट है। आपके पास एक ऐसा privateक्षेत्र हो सकता है जो कक्षा के बाहर कोई भी नहीं पहुंच सकता है। एफपी में मेरे लिए इसका कोई स्पष्ट सादृश्य नहीं है।
  5. मुझे लगता है कि अन्य प्रश्न हैं जो मुझे पूछने चाहिए लेकिन मुझे नहीं पता कि मुझे पूछना चाहिए। उन लोगों को भी जवाब देने के लिए स्वतंत्र महसूस करें।

अद्यतन करें

मुझे नील फोर्ड की यह बात पता चली कि इसमें एक बहुत ही प्रासंगिक स्लाइड है। मैं यहाँ स्क्रीनशॉट एम्बेड करूँगा:

यहाँ छवि विवरण दर्ज करें


1
मैं पूर्ण प्रश्न का उत्तर नहीं दे सकता, लेकिन (4) के रूप में, कुछ FP भाषाओं में मॉड्यूल सिस्टम हैं जो इनकैप्सुलेशन प्रदान कर सकते हैं।
एंड्रेस एफ।

@AndresF। आह हाँ, यह सच है। मैं भूल गया कि हास्केल में मॉड्यूल हैं और आप उनमें डेटा प्रकार और फ़ंक्शन छिपा सकते हैं। शायद जब मैं कहता हूं कि एफपी मैं वास्तव में क्लोजर कह रहा हूं। क्लोजर में आपके निजी कार्य और "फ़ील्ड" हो सकते हैं, लेकिन मुझे ऐसा लगता है कि यह आपके डेटा को किसी भी चीज़ को दिखाई देने और कहीं भी पास करने के लिए मुहावरेदार है।
डैनियल कपलान

6
आप जो करते हैं वह अक्सर आपके प्रकारों को दिखाई देता है, लेकिन अपने निर्माणकर्ताओं को छिपाएं। ये सार प्रकार विशेष रूप से OCaml मॉड्यूल सिस्टम द्वारा किया जाता है
डैनियल ग्रैज़र

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

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

जवाबों:


23

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

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

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

संपादित करें: मुझे रिच हिकी के साथ एक साक्षात्कार से एक प्रासंगिक उद्धरण मिला ।

फोगस: उस विचार के बाद-कुछ लोग इस तथ्य से आश्चर्यचकित हैं कि क्लॉज्योर अपने प्रकारों के डेटा-छिपाने के अंतराल में संलग्न नहीं है। आपने डेटा छिपाने का फैसला क्यों किया?

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


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

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

2
"कभी-कभी, एक साधारण डेटा संरचना आपको सभी की आवश्यकता होती है"। +1। कुछ OOP समझ में आता है, कुछ समय में यह FP है।
लॉरेंट बॉरगुल्स-रॉय

1
@Aaronaught यह उत्तर एफपीआर के लक्ष्यों में से एक होने के रूप में प्रतिरूपकता (जो कि इनकैप्सुलेशन और पुनः उपयोग दोनों) के बारे में इंगित करता है (जैसा कि "क्यों कार्यात्मक प्रोग्रामिंग मामलों" में चर्चा की गई है), इसलिए प्रश्न के उत्तर (1) को " नहीं"।
एंड्रेस एफ।

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

12

... और शायद उन लेखों में से एक है जो ओओपी पर आधारित थे।

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

पहले मैं जानना चाहता हूं कि क्या मेरा आकलन सही है। क्या एफपी प्रतिमान और यह लेख दार्शनिक रूप से असहमत है?

इसके अलावा, मेरी नजर में, एफपी कार्यक्रम जैसा दिखता है, आपका वर्णन प्रक्रियाओं या कार्यों का उपयोग करने वाले किसी भी अन्य से अलग नहीं है:

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

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

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

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

जहाँ तक डेटा चिंता का विषय है, आप FP का उपयोग करके डेटा सार और डेटा प्रकार सार को विस्तृत कर सकते हैं। इनमें से कोई भी ठोस संरचनाओं को छुपाता है और इन ठोस संरचनाओं के जोड़-तोड़ को अमूर्त के रूप में कार्य करता है।

संपादित करें

यहां यह कहते हुए कि "डेटा छुपाना" एफपी के संदर्भ में बहुत उपयोगी है (या OOP-ish (?)) बताते हुए यहां जोर की संख्या बढ़ रही है। इसलिए, मुझे SICP से एक बहुत ही सरल और स्पष्ट उदाहरण पर मुहर लगाने दें:

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

(define my-rat (cons 1 2)) ; here is my 1/2 

यदि आप डेटा अमूर्तता को अनदेखा करते हैं, तो सबसे अधिक संभावना है कि आप अंश और हर का उपयोग करके प्राप्त करेंगे carऔर cdr:

(... (car my-rat)) ; do something with the numerator

इस दृष्टिकोण के बाद, तर्कसंगत संख्याओं में हेरफेर करने वाले सिस्टम के सभी हिस्सों को पता चल जाएगा कि एक तर्कसंगत संख्या एक है cons- वे consतर्कसंगत बनाने के लिए और सूची ऑपरेटरों का उपयोग करके उन्हें निकालने के लिए संख्या होगी ।

एक समस्या जिसका आपको सामना करना पड़ सकता है, जब आपको तर्कसंगत संख्याओं के कम रूप की आवश्यकता होती है - पूरे सिस्टम में परिवर्तन की आवश्यकता होगी। यदि आप सृजन के समय को कम करने का निर्णय लेते हैं, तो आप बाद में यह पा सकते हैं कि तर्कसंगत शब्दों में से किसी एक का उपयोग करते समय कम करना बेहतर है, एक और पूर्ण पैमाने पर बदलाव ला सकता है।

एक अन्य समस्या यह है कि, यदि काल्पनिक रूप से, उनके लिए एक वैकल्पिक प्रतिनिधित्व पसंद किया जाता है और आप consप्रतिनिधित्व को छोड़ने का फैसला करते हैं - फिर से पूर्ण पैमाने पर परिवर्तन।

इन स्थितियों से निपटने में किसी भी तरह का प्रयास संभवतः इंटरफेस के पीछे तर्क का प्रतिनिधित्व छिपाने के लिए शुरू होगा। अंत में, आप कुछ इस तरह से समाप्त कर सकते हैं:

  • (make-rat <n> <d>)वह परिमेय संख्या लौटाता है जिसका अंश पूर्णांक है <n>और जिसका भाजक पूर्णांक है <d>

  • (numer <x>)परिमेय संख्या के अंश को लौटाता है <x>

  • (denom <x>)परिमेय संख्या के हर को लौटाता है <x>

और सिस्टम अब नहीं जानता (और अब नहीं होना चाहिए) कि क्या तर्कसंगत बनाये जाते हैं। इसका कारण यह है cons, carऔर cdrतर्कसंगत के लिए आंतरिक नहीं हैं, लेकिन make-rat, numerऔर denom हैं । बेशक, यह आसानी से एक एफपी प्रणाली हो सकती है। तो, "डेटा छिपाना" (इस मामले में, बेहतर डेटा अमूर्त के रूप में जाना जाता है, या अभ्यावेदन और ठोस संरचनाओं को घेरने का प्रयास) एक प्रासंगिक अवधारणा और व्यापक रूप से इस्तेमाल की जाने वाली तकनीक के रूप में आता है, चाहे वह ओओ, कार्यात्मक उपकरणों के संदर्भ में हो। जो कुछ।

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

  • परिवर्तनशीलता: क्या आवश्यक परिवर्तन स्थानीय स्तर पर किए जा सकते हैं या सिस्टम के माध्यम से फैले हुए हैं।
  • स्वतंत्र विकास: किस प्रणाली में दो भागों को समानांतर में विकसित किया जा सकता है।
  • व्यापकता: इसके एक हिस्से को समझने के लिए सिस्टम की कितनी आवश्यकता है।

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


मैं मानता हूं कि एफपी में डेटा छिपाना प्रासंगिक है। और, जैसा आप कहते हैं, इसे प्राप्त करने के तरीके हैं।
एंड्रेस एफ।

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

8

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

map :: (a -> b) -> [a] -> [b]
map _ [] = []
map f (x:xs) = f x : map f xs

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

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


5

मैं यहां एक अंग पर प्रहार करने जा रहा हूं और कहता हूं कि अवधारणा एफपी में प्रासंगिक नहीं है जिस तरह से ओओ में है।

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


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

यह विपरीत है कि सामान्य तौर पर आप अपने डेटा का प्रतिनिधित्व करने के लिए चीजों को मॉडल करते हैं। अप्रचलित कार सादृश्य:

OO

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

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

एफपी

  • आपके पास बहुत सारी गणनाएँ हैं जो आपको व्यवहारों का वर्णन करने की अनुमति देती हैं
  • व्यवहार की ये अभिव्यक्तियाँ एक तरह से संबंधित होती हैं, जिस तरह से कारों के व्यवहारों का संबंध प्रत्येक अभिभावक से होता है, जैसे कि एक कार जिसमें तेजी / मंदी होती है, दो व्यवहार होते हैं जो एक समान तरीके से प्रत्येक व्यवहार का विरोध करते हैं।

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

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

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


वापस सवाल पर, एफपी डेटा छिपाने के बारे में क्या कहता है, क्या वह इसकी सराहना करता है या इससे असहमत है या नहीं?

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


यह शानदार है, मुझे इसे पढ़ने में बहुत मजा आया। आपके योगदान के लिए धन्यवाद
क्रिस मैकॉल

5

यहाँ एक विरोधाभास सा है। भले ही कार्यात्मक प्रोग्रामिंग पर ध्यान केंद्रित किया जाता है, अच्छी तरह से, फ़ंक्शन, और अक्सर ऐसे फ़ंक्शन होते हैं जो सीधे आदिम डेटा प्रकारों पर काम करते हैं, यह ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग की तुलना में अधिक डेटा छुपाता है।

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

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

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

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

जहाँ तक बिंदु 4 (2 और 3 में दिए गए उत्तर का कोई मतलब नहीं है, जो मैंने बिंदु 1 के लिए कहा है) यह भिन्न होता है। यह OO भाषाओं में भी भिन्न होता है, और कई निजी क्षेत्रों में भाषा द्वारा लागू किए जाने के बजाय सम्मेलन द्वारा निजी होते हैं।


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

3

सबसे पहले, इस महान लेख के लिंक के लिए धन्यवाद, मुझे अब तक यह नहीं पता था, और इसने मुझे कुछ चीजों के बारे में कुछ महान इनपुट दिए, जिनकी मैं पिछले वर्षों में समुदाय के कुछ अन्य सॉफ्टवेयर डिजाइनरों के साथ चर्चा कर रहा था। यहाँ इसके बारे में मेरी राय है:

पहले मैं जानना चाहता हूं कि क्या मेरा आकलन सही है। क्या एफपी प्रतिमान और यह लेख दार्शनिक रूप से असहमत है?

एफपी डिजाइन डेटा-फ्लो पर बहुत ध्यान केंद्रित करता है (जो कि आईएमएचओ इतना बुरा नहीं है जितना कि आर्टिकल लगा सकता है)। यदि यह एक पूर्ण "असहमति" है तो यह निस्संदेह है।

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

IMHO इसकी भरपाई नहीं करता है। निचे देखो।

या, यह मानते हुए कि वे असहमत हैं, शायद एफपी को लगता है कि डेटा छिपाना बुरा है। यदि हां, तो यह क्यों लगता है कि डेटा छिपाना बुरा है?

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

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

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

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


3

टीएल; डीआर : नहीं

क्या एफपी प्रतिमान और यह लेख दार्शनिक असहमत है?

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

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

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

डेटा छिपाना

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

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

मैंने यह कभी नहीं कहा कि "लगभग व्यर्थ के प्रतिपादन करता है"। वो आपके विचार और आपके अकेले हैं। मैंने कहा कि आपको परिवर्तनशील चरों की कमी के कारण अधिक डेटा छिपाने की आवश्यकता नहीं है। यह इनकैप्सुलेशन या डेटा को बेकार नहीं बनाता है, यह सिर्फ इसका उपयोग कम करता है क्योंकि ये मामले मौजूद नहीं हैं। अन्य सभी मामले जिनमें डेटा छिपाना और एनकैप्सुलेशन उपयोगी हैं, अभी भी मान्य हैं।
डायटबुद्ध
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.