व्याख्यान में लिखा गया है "पहली प्रोग्रामिंग भाषा के रूप में हास्केल।" भाग २

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

पहला भाग

बहुरूपता

एक फ़ंक्शन बहुरूपी है यदि यह विभिन्न प्रकार के डेटा को संभालने में सक्षम है। सबसे सरल बहुरूपी कार्य पहचान समारोह है:

id :: a -> a id x = x 

बहुधा, बहुरूपता का उपयोग सूचियों के साथ काम करने के लिए किया जाता है (जो समझ में आता है):

 length :: [a] -> Int length [] = 0 length (_:l) = 1 + length l 

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

 filter :: (a -> Bool) -> [a] -> [a] filter p [] = [] filter p (x:xs) | px = x : filter p xs | otherwise = filter p xs 

फ़िल्टर फ़ंक्शन सूची में केवल उन तत्वों को छोड़ता है जो एक निश्चित स्थिति को संतुष्ट करते हैं।

जैसा कि आप देख सकते हैं, एक बहुरूपिक प्रकार भी एक फ़ंक्शन का एक डोमेन हो सकता है:

 error :: String -> a 

इस स्थिति में, त्रुटि फ़ंक्शन त्रुटि के बारे में एक इनपुट स्ट्रिंग लेता है और प्रकार का एक चर लौटाता है।
मापदंडों के बिना एक बहुरूपी फ़ंक्शन को बहुत दिलचस्प रूप से परिभाषित किया गया है - अपरिभाषित:

 undefined :: a undefined = error "Prelude.undefined" 

इस निरंतर फ़ंक्शन का उपयोग किसी भी प्रकार की अनिश्चित मात्रा को दर्शाने के लिए किया जाता है।

ऑपरेटरों

एक फ़ंक्शन जिसे तर्कों के बीच रखा जा सकता है उसे इन्फिक्स या, बस, एक ऑपरेटर कहा जाता है। (शब्द तर्कों का सशर्त उपयोग किया जाता है, हमें याद है कि हास्केल में दो तर्कों के कोई कार्य नहीं हैं)।
हास्केल सिंटैक्स आपको कथन बनाने के लिए निम्न वर्णों का उपयोग करने की अनुमति देता है:
": # $% * + - =। / \ <>? @ ^ | "
निम्नलिखित संयोजनों को छोड़कर संचालकों को आपकी तरह बनाया जा सकता है:
":: = ... - @ \ | | <- -> ~ => "
इस तथ्य के अलावा कि ऑपरेटर नाम कोष्ठक में संलग्न हैं, फ़ंक्शन परिभाषा उपसर्ग संकेतन में समान है। एक उदाहरण:

 (%%) :: Int -> Int -> (Int, Int) (%%) xy = (div xy, rem xy) 

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

सहकारिता द्वारा, संचालकों को साहचर्य, दाईं ओर साहचर्य, बाईं ओर साहचर्य और गैर-सामाजिक में विभाजित किया जाता है।
कुछ सशर्त ऑपरेटर "\ /":

• दाईं ओर सहयोगी यदि अभिव्यक्ति a / / b / c को a / / (b \ / c) के रूप में परिकलित किया जाता है
• बाईं ओर सहयोगी अगर अभिव्यक्ति a / / b \ / c (a / / b) \ / c के रूप में परिकलित किया जाता है
• साहचर्य यदि किसी क्रम में a \ / b \ / c का मूल्यांकन किया जा सकता है
• गैर-समरूप यदि अभिव्यक्ति a / b \ / c को कोष्ठक के बिना लिखा जाना मना है

हास्केल में:

• infixr - दाईं ओर समरूपता
• infixl - बाईं सहक्रियाशीलता
• infix - गैर-सहयोगी संचालक

इसलिए, जैसा कि हम ऑपरेटर लिखते हैं, प्राथमिकता और सहानुभूति को ध्यान में रखते हुए:

 infixr 7 -- ,  7 (\/) :: Bool -> Bool -> Bool (\/) xy = ... 

मानक प्रस्तावना संचालकों की प्राथमिकताएँ और संबद्धता:

 infixr 9 . infixl 9 !! infixr 8 ^, ^^, ** infixl 7 *, /, `quot`, `rem`, `div`, `mod`, :%, % infixl 6 +, - infixr 5 :, ++ infix 4 ==, /=, <, <=, >=, >, `elem`, `notElem` infixr 3 && infixr 2 || infixl 1 >>, >>= infixr 1 =<< infixr 0 $, $!, `seq` 

currying

तो, हास्केल में दो या अधिक तर्कों का एक समारोह क्यों नहीं है? फ़ंक्शन पर विचार करें:

 plus :: (Integer, Integer) -> Integer plus (x, y) = x + y 

प्लस फ़ंक्शन का एक तर्क है। यह तर्क संख्याओं की एक जोड़ी है।
आमतौर पर हास्केल के कार्यों को निम्न प्रकार से लिखा जाता है:

 plus :: Integer -> Integer -> Integer plus xy = x + y 

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

 successor :: Integer -> Integer successor = plus 1 

इस तकनीक को फ़ंक्शन का आंशिक अनुप्रयोग कहा जाता है।

प्रस्तावना विशेष कार्यों करी और अस्वाभाविकता को परिभाषित करती है, प्रमुख कार्यों को करीने के रूप में और इसके विपरीत:

 curry :: ((a, b) -> c) -> a -> b -> c curry fxy = f (x, y) uncurry :: (a -> b -> c) -> ((a, b) -> c) uncurry fp = f (fst p) (snd p) 

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