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