एक और मोनाद गाइड (भाग 1: मूल बातें)

माइक वनियर द्वारा

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

1. मुझे लगता है कि मैं कई अन्य मैनुअल की तुलना में भिक्षुओं के कुछ पहलुओं को बेहतर तरीके से समझा सकता हूं।
2. मैंने भिक्षुओं को अब से बेहतर समझना शुरू कर दिया है और मैं जितना संभव हो उतना साझा करना चाहता हूं।

आवश्यक शर्तें

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

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

मना करना ...

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

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

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

प्रेरणा: आपको भिक्षुओं के बारे में क्यों सोचना चाहिए?

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

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

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

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

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

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

मोनाड्स प्रोग्रामिंग भाषाओं के सिद्धांत में अद्भुत विचारों में से एक हैं, और वे खोज के लायक हैं।

परिभाषा: सन्यासी क्या हैं?

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

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

कंप्यूटिंग की अवधारणा

खैर, चलिए परिभाषा का हमारा विश्लेषण "कंप्यूटिंग की अवधारणा" के साथ शुरू करते हैं।

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

एफ :: ए -> बी

यहाँ, डबल कॉलन "::" का अर्थ है "निम्न प्रकार है।" इस प्रकार, फ़ंक्शन f में एक कार्यात्मक प्रकार a -> b होता है, और इसका अर्थ है कि फ़ंक्शन प्रकार का मान लेता है और प्रकार b का मान लौटाता है। व्यवहार में, ए और बी में आमतौर पर ठोस प्रकार होते हैं: इंट, फ्लोट, स्ट्रिंग ..., लेकिन हास्केल में, तर्क प्रकारों की परवाह किए बिना भी कार्य कर सकते हैं। ({3})

इसलिए, शुद्ध कार्य सबसे सरल हैं "अभिकलन की अवधारणा।" और क्या गणना अभी भी मौजूद है? उनमें से कई हैं, और आप कई से परिचित हैं; इसमें गणना शामिल है:

• इनपुट / आउटपुट (फाइलें, कंसोल) के साथ काम करें;
• अपवाद;
• कुछ सामान्य स्थिति (वैश्विक, स्थानीय) बदलें;
• कभी-कभी वे असफल हो सकते हैं;
• एक साथ कई परिणाम लौटाएं;
• और कई अन्य।

सूचना: मैंने "इनपुट / आउटपुट" वाक्यांश का उपयोग किया है, या संक्षिप्त रूप से I / O का उपयोग किया है, जिसका अर्थ है कि फ़ाइल या कंसोल के साथ काम करते समय इनपुट / आउटपुट। I / O ऑपरेशन साइड इफेक्ट्स को ले जाने के लिए जाने जाते हैं। किसी फ़ंक्शन के इनपुट और आउटपुट मान के साथ I / O ऑपरेशन को भ्रमित न करें।

सामान्य प्रोग्रामिंग भाषाओं में इन गणनाओं के साथ आप कैसे काम करेंगे, इसके बारे में एक दूसरा विचार करें - सी या जावा में। इनपुट / आउटपुट संचालन के साथ गणना? कोई बात नहीं! C और Java का कोई भी फंक्शन। अपवादों को बुलाने के बारे में क्या? सी में, यह थोड़ा जटिल है क्योंकि अपवादों के लिए कोई भाषा समर्थन नहीं है, लेकिन आप विफलता की स्थिति में एक त्रुटि कोड वापस कर सकते हैं। (या अगर आप एक अनुभवी निम्न-स्तरीय प्रोग्रामर हैं तो सेटजम्प / लॉन्गजम्प के साथ सामान्य रूप से त्रुटियों को संभाल सकते हैं।) जावा में, आप बस एक अपवाद को इस उम्मीद में फेंक देते हैं कि यह कहीं पर संभाला जाएगा। अपवादों के अलावा, अभी भी एक शर्त है - इसके साथ कैसे काम करें? हां, सामान्य तौर पर, यह सरल है: सी और जावा में, आप विभिन्न तरीकों से वैरिएबल, ग्लोबल और स्थानीय को पढ़ और लिख सकते हैं। और गणना जो विफल हो सकती है? उन्हें अपवादों के पतित मामले के रूप में देखा जा सकता है, इसलिए फिर से कोई समस्या नहीं है। अंत में, कई मूल्यों को लौटाने वाली गणनाओं के बारे में क्या? यहां, मूल्यों की एक भीड़ से मेरा मतलब है कि एक ऐसी वस्तु नहीं जिसमें परिणामों का एक गुच्छा होता है - न कि एक सी संरचना या एक जावा वस्तु - मैं उन कार्यों के बारे में बात कर रहा हूं जो कई अलग-अलग परिणामों को "समानांतर में" वापस कर सकते हैं। यह पूरी तरह से स्पष्ट नहीं है कि सी या जावा में ऐसा कैसे करें। ({4})

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

केवल एक निष्कर्ष है: हम दो कुर्सियों पर बैठना चाहते हैं। ({5}) हम जहां भी संभव हो, शुद्ध कार्यों में कोड लिखना चाहते हैं, इसके सभी लाभ प्राप्त करना: आसान डिबगिंग, सत्यापन ... लेकिन हम इस "कुछ और" के साथ भी नियंत्रित तरीके से काम करना चाहेंगे, क्योंकि नहीं किसी विशेष स्थिति में बेहतर होना और यह वही है जो हमें अनुमति देता है।

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

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

कार्यों के कार्य, आवेदन (आवेदन) और कार्यों की संरचना

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

एफ :: ए -> बी

इस प्रकार, एफ एक प्रकार का है -> बी ("ए से बी तक पढ़ें")। यहाँ एक फ़ंक्शन का अधिक विशिष्ट उदाहरण है जो इनपुट मान को दोगुना करता है:

एफ :: इंट -> इंट
f x = 2 * x

f, Int -> Int का प्रकार है, क्योंकि यह एक पूर्णांक लेता है, इसे दो से गुणा करता है, और दूसरा पूर्णांक देता है।

फ़ंक्शन निष्पादित करने के लिए सरल है, इसके लिए हम इसे तर्क पर लागू करते हैं (हम मानते हैं कि इसका एक तर्क है)। यह आमतौर पर फ़ंक्शन के तर्क को बताकर किया जाता है:

f 2 - फ़ंक्शन "f 2" मान = 4।

ध्यान दें कि हास्केल में, कई अन्य प्रोग्रामिंग भाषाओं की तरह, कोष्ठक में तर्क दिखाई नहीं देते हैं।

currying

व्यवहार में, कई कार्यों के लिए एकल तर्क कार्य पर्याप्त नहीं हैं। हम दो तर्क फ़ंक्शन को कैसे परिभाषित करते हैं? उदाहरण के लिए, हम एक फ़ंक्शन q लिख सकते हैं जो दो पूर्णांक तर्क लेता है और उनके वर्गों का योग लौटाता है? समारोह का शरीर लिखने के लिए सरल है:

q x y = x * x + y * y

फ़ंक्शन प्रकार हस्ताक्षर छोड़ा गया। शायद आपको किसी प्रकार के विकल्प की उम्मीद है:

q :: इंट -> इंट

या शायद यह:

q :: ( इंट , इंट ) -> इंट

वास्तव में, इस फ़ंक्शन का प्रकार इस तरह दिखता है:

q :: इंट -> इंट -> इंट

तीर "->" सही-सहयोगी है, इसलिए प्रविष्टि का अर्थ निम्न है:

q :: इंट -> ( इंट -> इंट )

अब यह दिलचस्प लग रहा है। दो तर्क फ़ंक्शन, जो हास्केल में एक तर्क (हमारे मामले में x) का कार्य बन जाता है, एक तर्क का दूसरा फ़ंक्शन देता है, जो बदले में अगला तर्क (y) लेता है और परिणाम देता है। और यह सही है, क्योंकि Haskell में, अन्य FY के रूप में, फ़ंक्शन को अन्य फ़ंक्शन के मान के रूप में वापस किया जा सकता है। (दूसरे शब्दों में, FJ में फ़ंक्शन केवल एक अलग डेटा प्रकार हैं।) एकल-तर्क के रूप में बहु-तर्क कार्यों का प्रतिनिधित्व करने के इस तरीके को करी (हस्केल करी के बाद, जिसका नाम हास्केल भी कहा जाता है। वैज्ञानिक रूप से Scheinfinkel द्वारा स्वतंत्र रूप से खोला जाता है। इसलिए आप इसे कॉल कर सकते हैं। प्रक्रिया और इसलिए, यदि आप चाहते हैं)। स्पष्टीकरण के लिए, आइए एक फ़ंक्शन r को चार पूर्णांक तर्क w, x, y और z के साथ लेते हैं, जो एक पूर्णांक लौटाता है।

r :: इंट -> इंट -> इंट -> इंट -> इंट
r w x y z = ... w, x, y और z का कार्य है

सही-सहयोगी तीर देता है:

r :: इंट -> ( इंट -> ( इंट -> ( इंट -> इंट ) ) )
r w x y z = ... w, x, y और z का कार्य है

जहाँ r एक पूर्णांक तर्क w का एक फ़ंक्शन है, जो टाइप का एक फ़ंक्शन देता है (Int -> (Int -> (Int -> Int)))। वह फ़ंक्शन, जब पूर्णांक (हमारे उदाहरण में x) पर लागू होता है, तो प्रकार (Int -> (Int -> Int)) का एक फ़ंक्शन देता है। अगले फ़ंक्शन को पूर्णांक (उदाहरण में y) पर लागू किया जा रहा है, प्रकार का एक फ़ंक्शन देता है (Int -> Int), जो बदले में, जब किसी अन्य पूर्णांक (z) पर लागू होता है, तो एक पूर्णांक देता है - कॉल (rwxyz) का परिणाम, जो , वास्तव में, (((((rw) x) y) z)। और इसे क्युरिंग कहा जाता है। हास्केल स्वचालित रूप से कार्यों को पूरा करता है। करी बहुत सुविधाजनक है क्योंकि आप एक बार में एक तर्क पारित कर सकते हैं, और एक ही बार में नहीं, और ये आंशिक रूप से लागू फ़ंक्शन अक्सर अपने आप में बहुत उपयोगी होते हैं। और करी भी हमारे लिए वैचारिक रूप से उपयोगी है कि अब से यह हमारे लिए एक तर्क के कार्यों के बारे में सोचने के लिए पर्याप्त है, और इससे अधिक कुछ नहीं। वाह!

हास्केल में एक विशेष $ ऑपरेटर है, यह एक फ़ंक्शन ऑपरेटर है। इसके निम्न प्रकार हैं:

( $ ) :: ( a -> b ) -> a -> b

(हास्केल में, प्रतीकात्मक infix संचालक कोष्ठकों में संलग्न समान नाम के कार्यों के समतुल्य हैं। इस प्रकार, संकेतन f $ 2 संकेतन के समान है ($) f 2. संचालक आमतौर पर उनके कार्यात्मक रूप में परिभाषित किए जाते हैं - सुविधा के लिए। भाषा पर परिचयात्मक सामग्रियों का संदर्भ लें। यदि आप अधिक जानना चाहते हैं, तो हम अक्सर यहां के ऑपरेटरों का उपयोग करेंगे।)

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

f 2 -> 4 वापस आएगा
f $ 2 -> 4 भी लौटाएगा
( $ ) f 2 -> और यहाँ 4 वापस आएगा

आप एक ही चीज़ को लिखने के तीन अलग-अलग तरीके देखते हैं।

$ ऑपरेटर की वास्तव में यहाँ ज़रूरत नहीं है, क्योंकि इसे निष्पादित करने के लिए किसी फ़ंक्शन में तर्क को स्थानापन्न करना तकनीकी रूप से आसान है। लेकिन हित के लिए, हम "रिवर्स एप्लिकेशन" ऑपरेटर को निर्दिष्ट कर सकते हैं, इसे> $> कॉल कर सकते हैं, और इसे रिवर्स ऑर्डर में समान तर्क दे सकते हैं:

( > $> ) :: a -> ( a -> b ) -> b
x > $> f = f x - = f $ x के समान

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

अब जब हमने फ़ंक्शन का उपयोग करने के बारे में बात की है, तो अगला महत्वपूर्ण विषय फ़ंक्शन की संरचना है। और यह वास्तव में एक महत्वपूर्ण विषय है। मान लें कि हमारे पास दो कार्य f और g हैं, साथ ही निम्नलिखित फॉर्म का x मान भी है:

x :: ए
एफ :: ए -> बी
जी :: बी -> सी

जहाँ a, b, c कुछ प्रकार हैं। आप इन एक्स, एफ, और जी के साथ निम्नलिखित कर सकते हैं: एक्स ले लो, फ़ंक्शन एफ को उस पर लागू करें (टाइप बी का मान प्राप्त करें), और फिर फ़ंक्शन जी को परिणाम पर लागू करें।टाइप x का मान टाइप b के मान में बदल जाएगा, और फिर जो हुआ वह टाइप c के मान में परिवर्तित हो जाएगा। हास्केल में यह कहना आसान है:

जी ( एफएक्स )

लेकिन यह केवल तभी काम करेगा जब प्रकार f और g संगत हों, अर्थात, यदि फ़ंक्शन f का परिणाम फ़ंक्शन जी के तर्क के समान प्रकार का है (हमारे मामले में, यह टाइप बी है)। एक फ़ंक्शन का दूसरे में उपयोग करने के लिए दूसरे तरीके से व्याख्या की जा सकती है: हम क्रमशः दो कार्यों f और g के प्रकारों को लेते हैं, क्रमशः - a>> b और b -> c, और प्रकार का तीसरा फ़ंक्शन a -> c बनाते हैं। इसे तर्क x पर लागू करने पर, हमें टाइप सी का परिणाम मिलता है। दो कार्यों को एक तिहाई में संयोजित करने के इस विचार को कार्यों की संरचना कहा जाता है। हास्केल भी एक साधारण फंक्शन कंपोजिशन ऑपरेटर को परिभाषित करता है:

( . ) :: ( b -> c ) -> ( a -> b ) -> ( a -> c )
g . f = \x -> g ( f x )

यहां हम नोटेशन "\ x -> ..." का उपयोग करते हैं, जो एक तर्क x के साथ एक लैम्ब्डा अभिव्यक्ति (या, एक ही बात, एक अनाम फ़ंक्शन) को दर्शाता है। यह है कि रचना संचालक दो कार्यों को तर्क के रूप में लेता है और तीसरा लौटाता है। और फिर से: वित्त वर्ष में, तर्क और रिटर्न मान के रूप में कार्य एक काफी सामान्य घटना है जो हर कदम पर होती है।

कभी-कभी रचना ऑपरेटर के साथ एक उपद्रव होता है जब फ़ंक्शन गलत क्रम में पालन करते हैं। लेकिन हम "रिवर्स कंपोजिशन ऑपरेटर">> लिख सकते हैं:

( >।> ) :: ( a -> b ) -> ( b -> c ) -> ( a -> c )
f >> g = \ x -> g ( fx )

हम इसे फ़ंक्शन> $> के उलटा ऑपरेटर के माध्यम से भी व्यक्त कर सकते हैं:

( >>। ) :: ( एक -> ख ) -> ( ख -> ग ) -> ( एक -> ग )
च । >> जी = \ एक्स -> एक्स > $> च > $> जी

या इससे भी सरल - रचना ऑपरेटर के माध्यम से:

( >।> ) :: ( ए -> बी ) -> ( बी -> सी ) -> ( ए -> सी )
एफ >> जी = जी । च

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

आइए एक उदाहरण का विश्लेषण करें:

च :: इंट -> इंट
fx = 2 * एक्स

जी :: इंट -> इंट
GY = 3 + y

ज :: इंट -> इंट
ज = छ । f - या वही: f>> जी

फंक्शन h यहाँ क्या कर रहा है? यह एक पूर्णांक लेता है, इसे 2 से गुणा करता है और 3 जोड़ता है। अर्थात्, यह निम्नलिखित विकल्प के बराबर है:

h :: Int -> Int
hx = 3 + 2 * x

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

एक्स F11 =
जाने
x2 = f1 एक्स
x3 = f2 x2
x4 = f3 x3
x5 = F4 x4
x6 = F5 x5
x7 = F6 x6
x8 = F7 x7
x9 = F8 x8
x10 = F9 x9
X11 = F10 x10
में
X11

बहुत थका हुआ है, है ना? अब कार्यों की संरचना को देखें:

f11 = f10 । f9 । f8 । f7 । f6 । f5 । f4 । f3 । f2 । f1

या, एक ही बात:

f11 = f1 >।> f2 >। f3 >।> f4 >।> f5 >> f6 >> f7 >।> f8 >।> f9 >> f10

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

सामग्री को मजबूत करने, प्रतिबिंब के विषय:

• फ़ंक्शंस, फ़ंक्शंस (एप्लिकेशन), फ़ंक्शंस की रचना, फ़ंक्शनल प्रोग्रामिंग की मूलभूत अवधारणाओं के रूप में कार्य करता है।
• कार्यों को लागू करने के लिए ऑपरेटर, उन कार्यों की रचना के लिए जो हम चाहते हैं किसी भी क्रम में तर्क लेते हैं।

मोनाडिक कार्य, मोनैडिक मान

अब तक, मैंने जो कुछ भी बताया है, मुझे उम्मीद है, काफी सरल रहा है। अब हम और अधिक जटिल चीजों की ओर बढ़ते हैं।

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

एफ :: ए - [कुछ और] -> बी

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

बेशक, संकेतन "- [कुछ और] ->" हास्केल में अमान्य है; थोड़ी देर बाद हम देखेंगे कि यह वास्तव में कैसा दिखता है, और मुझे आशा है कि यह स्पष्ट होगा। अब हम ऊपर वर्णित संगणना की अवधारणाओं की तुलना करने के लिए इन अधिसूचनाओं से चिपके रहेंगे; हम हास्केल में मठों के अनुरूप गणना नामों की प्रत्येक अवधारणा देंगे।

1. , / . I/O IO, :
   

   f :: a --[IO]--> b

   (, IO , .)
2. , . :
   

   f :: a --[error]--> b

3. , . State:
   

   f :: a --[State s]--> b

4. , . Maybe:
   

   f :: a --[Maybe]--> b

5. , . list ():
   

   f :: a --[list]--> b

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

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

एफ :: ए - [आईओ] -> बी

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

f :: IO a -> b

या

f :: a -> IO b

यह पता चला है कि हास्केल एक दूसरे रूप में विवादास्पद कार्यों के लिए संकेतन का उपयोग करता है:

f :: a -> mb

किसी भी मोनाड m के लिए; उदाहरण के लिए, IO के लिए। (कट्टर कामगारों के लिए, मैं ध्यान देता हूं कि कोमोनैड्स की एक अवधारणा है, जहां प्रत्येक फ़ंक्शन में कुछ कॉमनॉड सी के लिए f :: ca -> b है। आइए हम इस लेख को भविष्य के लेखों के लिए छोड़ दें।)

ठीक है, ठीक है, वास्तव में प्रवेश के पीछे निहित है: a -> mb ”? एक रिकॉर्ड का मतलब है कि कुछ साधारण (शुद्ध) फ़ंक्शन एफ है जो टाइप ए का मान लेता है और टाइप एमबी (जो भी वे) का मान लौटाता है। तो, हास्केल में, मोनड फ़ंक्शंस के साथ मोनड फ़ंक्शंस शुद्ध कार्य हैं । दूसरे शब्दों में, एक शुद्ध कार्य सामान्य मूल्य लेता है और मानस लौटाता है। और इसका क्या मतलब है?

प्रवेश "एमबी" को स्पष्टीकरण की आवश्यकता है। b - यह कुछ प्रकार है। m कुछ मोनड का प्रतिनिधित्व करता है। हालाँकि, वास्तव में क्याहास्केल में मीटर द्वारा समझा गया? हास्केल में, "एम" एक प्रकार का निर्माता होना चाहिए - प्रकारों पर एक विशेष कार्य: यह एक तर्क लेता है और एक प्रकार देता है। यह उतना अजीब नहीं है जितना यह लग सकता है। "पूर्णांक की सूची" की अवधारणा पर विचार करें, जिसमें हास्केल का प्रकार [इंट] जैसा दिखता है। "कुछ की सूची" भाग को एक प्रकार के निर्माता के रूप में समझा जा सकता है जो एक निश्चित प्रकार (इंट) लेता है और एक अन्य प्रकार (पूर्णांक की सूची, [इंट]) लौटाता है। हास्केल के वर्ग कोष्ठक सूचियों को निरूपित करने के लिए कठोर हैं, लेकिन आप अपने प्रकार के निर्माणकर्ताओं को परिभाषित कर सकते हैं। इसके अलावा, किसी भी पॉलीमॉर्फिक प्रकार का अपना निर्माता है। सबसे सरल बहुरूपी प्रकारों में से एक, शायद, के रूप में परिभाषित किया गया है

डेटा शायद ए = कुछ नहीं | बस ए

यह यहाँ कहता है कि हो सकता है कि एक प्रकार का निर्माता है जो एक प्रकार (जिसे कहा जाता है) लेता है और आउटपुट मूल्य के रूप में एक नया प्रकार बनाता है। यदि हम Int का प्रकार टाइप करते हैं, तो हमें एक नया प्रकार शायद Int मिलेगा, जिसे निम्न प्रकार से लिखा गया है:

डेटा शायद Int = कुछ नहीं | बस int

तो हो सकता है कि एक प्रकार का फ़ंक्शन है जो एक प्रकार से दूसरे में मैप करता है।

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

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

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

हम अभी-अभी आए हैं जो भिक्षुओं को "समझने में मुश्किल" बनाता है।

चलो फिर से तैयार करते हैं।

1. "शुद्ध फ़ंक्शन" की एक परिचित अवधारणा है, अर्थात्, एक ऐसा फ़ंक्शन जो कुछ भी नहीं करता है, लेकिन केवल एक प्रकार के इनपुट मूल्य को दूसरे प्रकार (या शायद उसी) के आउटपुट मूल्य में परिवर्तित करता है।
2. , - . «- » / , , , , . , « ». , , .
3. Haskell — , - . «».

अब हम इस प्रश्न को सुधारते हैं: हम "राक्षसी अर्थ" के सार के बारे में क्या कह सकते हैं?

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

हालाँकि, हास्केल साहित्य में आप दो सामान्य तरीकों से व्याख्या कर सकते हैं जैसे कि मोनडिक अर्थ (अच्छी तरह से, और मूर्खतापूर्ण तरीकों का एक गुच्छा जो कई मैनुअल पाप करते हैं):

1. प्रकार मा (कुछ मोनाड एम के लिए) का मानसिक मूल्य "कार्रवाई" का एक विशेष प्रकार है जो कुछ करता है और प्रकार का मान लौटाता है। कार्रवाई का सार प्रत्येक विशिष्ट मोनड पर निर्भर करता है।

2. टाइप मा (कुछ मोनाड एम के लिए) का एक मानादिक मूल्य एक कंटेनर है जिसमें टाइप ए का मान संग्रहीत किया जाता है।

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

चलो हमारे कार्य को लेते हैं, मुझे आशा है कि यह एक प्रारंभिक बिंदु के रूप में बहुत स्पष्ट है:

f :: a -> mb

फिर फ़ंक्शन fx, जहां x एक प्रकार का है, प्रकार mb का होगा:

x :: a
fx :: mb

fx अब एक "विवादास्पद अर्थ" है, जो पूरी तरह से सहज नहीं है। एक अन्य समारोह पर विचार करें:

g :: a -> ( ) -> a
gx ( ) = x

जी का शाब्दिक रूप से निम्नलिखित है: यह किसी भी प्रकार का मान लेता है और इसे किसी फ़ंक्शन में लपेटता है, इसलिए आप जी को एक खाली मान देकर परिणाम प्राप्त कर सकते हैं। ({6}) खाली प्रकार और मूल्य हास्केल में उसी तरह कोष्ठक () में लिखे गए हैं, और यह सिर्फ एक प्रकार / मूल्य है जो हमारे लिए महत्वपूर्ण नहीं है। (शब्द "खाली" का अर्थ है कि यह मूल्य हमारे लिए किसी भी ब्याज का प्रतिनिधित्व नहीं करता है।) यहाँ एक उदाहरण है:

h = g 10
h ( ) - संख्या 10 की गणना की जाएगी

अब, हम g (fx) फ़ंक्शन का आविष्कार करके क्या प्राप्त करते हैं? आइए देखें प्रकार:

fx :: mb -
जी के ऊपर देखें :: a -> ( ) -> a
g ( fx ) :: ( ) -> mb

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

यहाँ मेरा विचार है। यदि आपको लगता है कि आपको यह समझने की आवश्यकता है कि एक मानदिक मान (प्रकार mb) क्या है, तो इसे प्रकार का एक विवादास्पद कार्य माना जाता है () -> mb, अर्थात, एक ऐसा कार्य जो न केवल प्रकार मान के लिए एक खाली मान को मैप करता है, बल्कि कुछ भी करता है कुछ और। यह ऐसा है मानो प्रकार mb का मान फ़ंक्शन का एक प्रकार है () -> mb, केवल भिन्न तरीके से लिखा गया है। तो बोलने के लिए, मौद्रिक अर्थ "गुप्त कार्य" हैं। इसलिए, उन्हें अक्सर "क्रियाएं" कहा जाता है, और कार्यों के साथ जुड़ा हुआ है, लेकिन काफी कार्य नहीं हैं। (कभी-कभी हम यह भी कहते हैं कि "एक कार्य निष्पादित करें", जो एक फ़ंक्शन का उपयोग करने के समान है।)

कुछ उदाहरण अभी चोट नहीं करेंगे। हास्केल में दो I / O फ़ंक्शन का उपयोग करूंगा:

getLine :: IO स्ट्रिंग
putStrLn :: स्ट्रिंग -> IO ( )

getLine एक "फ़ंक्शन" है (वास्तव में एक राक्षसी मूल्य, जिसे "मोनडिक कार्रवाई" के रूप में भी जाना जाता है) जो कंसोल से पाठ की एक पंक्ति पढ़ता है और किसी तरह इसे वापस करता है। putStrLn एक फ़ंक्शन (इस बार वास्तव में एक फ़ंक्शन) है जो एक स्ट्रिंग को एक तर्क के रूप में लेता है और इसे कंसोल में प्रिंट करता है, एक लाइन टर्मिनेटर जोड़ता है।

एक दूसरे के बारे में सोचें कि पारंपरिक भाषाओं में इन कार्यों के प्रकार कैसे दिखेंगे। हम कुछ इस तरह से मान सकते हैं:

getLine :: ( ) -> स्ट्रिंग - हास्केल में नहीं
putStrLn :: स्ट्रिंग -> ( ) - हास्केल में नहीं

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

getLine :: स्ट्रिंग
putStrLn :: स्ट्रिंग

और यह सच नहीं है: getLine सिर्फ एक स्ट्रिंग नहीं है; इसे स्ट्रिंग वापस करने के तर्क के साथ बुलाया जाना चाहिए। इसी तरह, putStrLn सिर्फ एक स्ट्रिंग नहीं है; क्योंकि उसे एक स्ट्रिंग तर्क की आवश्यकता है, हालांकि यह कोई फर्क नहीं पड़ता कि क्या लौटाता है। प्रत्येक मामले में, इनपुट या आउटपुट वैल्यू को स्थान देने के लिए खाली मानों की आवश्यकता होती है।

लेकिन हास्केल वापस। हमारे पास है:

getLine :: IO स्ट्रिंग
putStrLn :: स्ट्रिंग -> IO ( )

PutStrLn फ़ंक्शन के प्रकार को समझना आसान है। यह सिर्फ मठ IO के अंदर एक राक्षसी कार्य है। यह समझा जाता है कि यह प्रिंट करने के लिए एक स्ट्रिंग लेता है, एक खाली मान (कोई फर्क नहीं पड़ता) देता है, और "कुछ और" करता है। (इस मामले में, एक लाइन प्रिंट करने के लिए कंसोल के साथ इंटरेक्ट करना IO monad आपको करने की अनुमति देता है।)

गेटलाइन फ़ंक्शन का प्रकार समझने में अधिक कठिन है। getLine एक मानद मूल्य है। लेकिन हमारे लिए यह सोचने में आसान है कि यह एक प्रकार का एक प्रकार्य समारोह () -> IO स्ट्रिंग है। तब यह समझ में आता है: यह एक ऐसा फ़ंक्शन है जो कंसोल के साथ बातचीत करते समय कोई महत्व नहीं रखता है और स्ट्रिंग लौटाता है (अर्थात, यह कंसोल में आपके द्वारा टाइप किए जाने का इंतजार करता है)।

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

अगले लेख में, हम दो मौलिक मौद्रिक कार्यों के बारे में बात करेंगे: वे कहाँ से आए थे और उनके पीछे क्या है।

सामग्री

भाग 1: मूल बातें
भाग 2: कार्य >> = और वापसी
भाग 3: मोनाद कानून
भाग 4: शायद मोनाड और सूची मोनाड

नोट

{1} मूल में, "त्रुटियों के लिए प्रवण" - "कीड़े के लिए प्रवण", जिसे कुछ अलग तरीके से अनुवादित किया जा सकता है। ;)
{3} इसे "पैरामीट्रिक बहुरूपता" कहा जाता है।
{४} लेखक का अर्थ है कार्यों के परिणामस्वरूप एक ही प्रकार की वस्तुओं का समूह। उनकी राय में, समस्या यह है कि फ़ंक्शन विभिन्न संख्याओं को वापस कर सकते हैं: शून्य से n तक, अर्थात, वस्तुओं की संख्या अग्रिम में ज्ञात नहीं है। सी और जावा दोनों में, यह समस्या प्रभावी रूप से गतिशील डेटा प्रकारों द्वारा हल की जाती है।
{५} मूल में - एक निरंतर अभिव्यक्ति: "हमारा केक है और इसे भी खाएं।"
{6} मूल में - "एकल" मान, इकाई।

अनुवादक से

मुझे लेखक की अन्य सामग्रियों के लिंक अभी तक नहीं मिले हैं। मैं अपना लाऊंगा।
1. हास्केल ट्यूटोरियल अंग्रेजी में हास्केल ट्यूटोरियल और लेखों का सबसे व्यापक संग्रह।
2. Xgu.ru पर हास्केल - कई उपयोगी लिंक।
3. रूसी लैम्बडा ग्रह - रूसी में वायुसेना पर जानकारी का एक उत्कृष्ट स्रोत।
4. हास्केल ग्रह - अंग्रेजी में हास्केल और एफपी पर जानकारी का एक और भी उत्कृष्ट स्रोत है।