Polymorphy और हास्केल में कक्षाएं

नमस्कार प्रिय पाठक!

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

बहुरूपता

हास्केल में, दो प्रकार के बहुरूपता हैं - पैरामीट्रिक और विशेष (अंग्रेजी में वे "तदर्थ" शब्द कहते हैं, जो लैटिन भाषा से आया है)।

पैरामीट्रिक

यदि आपने कभी हास्केल भाषा को प्रोग्राम किया है, तो आप निश्चित रूप से कार्यों की length, head, teal, curry, uncurry, map, filter, ... में पैरामीट्रिक बहुरूपता के उदाहरणों में length, head, teal, curry, uncurry, map, filter, ... इन सभी कार्यों को क्या एकजुट करता है? आइए उनमें से कुछ के कार्यान्वयन को देखें:

 length :: [a] -> Int length [] = [] length (_:xs) = 1 + length xs head :: [a] -> a head (x:_) = x tail :: [a] -> [a] tail (_:xs) = xs curry :: ((a,b) -> c) -> (a -> b -> c) curry fxy = f (x,y) uncurry :: (a -> b -> c) -> ((a,b) -> c) uncurry g (x,y) = gxy 

पहले तीन फ़ंक्शंस में एक प्रकार का इनपुट पैरामीटर a , जबकि curry और uncurry में b और c । एक विशिष्ट डेटा प्रकार के बजाय ( Int, Bool, Char, ...), टाइपिंग का उपयोग किया जाता है। जावा उदाहरण:

 public class Test<A> {...} 

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

हास्केल भाषा में सभी प्रकार के चर के a, abc, aA101 अक्षर (उदाहरण के लिए a, abc, aA101 ) से शुरू होना चाहिए, और सभी विशिष्ट प्रकार (निर्माता) एक कैपिटल लेटर (उदाहरण के लिए String, Int, Node ) से शुरू होते हैं।

पैरामीटर किसी भी प्रकार को ले सकता है, यह हो सकता है इंट, स्ट्रिंग या यहां तक ​​कि फ़ंक्शन (उदाहरण के लिए, length [f, g, h] , जहां एफ, जी, एच एक ही प्रकार के कार्य हैं)। यह ध्यान देने योग्य है कि टाइप b किसी भी प्रकार का ले सकता है, जिसमें पैरामीटर का प्रकार भी शामिल है a ।

GHCi दुभाषिया (और हग) में फ़ंक्शन का प्रकार हमेशा कमांड का उपयोग करके पाया जा सकता है :t उदाहरण के लिए, :t :

 Main>:t length length :: [a] -> Int 

विशेष (तदर्थ)

विशेष बहुरूपता का पर्यायवाची शब्द है "अतिभारित कार्य"। यह पैरामीट्रिक की तुलना में एक कमजोर प्रकार का बहुरूपता है। उदाहरण के लिए अतिरिक्त संचालक (फ़ंक्शन) (+) लें। इस तरह की अभिव्यक्ति
(+) 2 3 ->> 5
(+) 2.5 3.85 ->> 6.35
भावों से अलग
(+) True False
(+) [1,2,3] [3,2,1]
उस में, पहले मामले में, संख्यात्मक मूल्यों का उपयोग किया गया था, और दूसरे में, बूल और [इंट] प्रकार के मान। इसके अलावा ऑपरेटर गैर-संख्यात्मक प्रकारों के लिए परिभाषित नहीं है। ऐसा इसलिए है क्योंकि यह फ़ंक्शन प्रकार का नहीं है
(+) :: a -> a -> a
और ऐसे
(+) :: Num a => a -> a -> a । यही है, इनपुट (और आउटपुट) डेटा के प्रकार पर प्रतिबंध है।

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

निम्नलिखित बाइनरी ट्री प्रकार दिए गए हैं:
एक बाइनरी ट्री जो किसी भी प्रकार के डेटा को स्टोर कर सकता है

 data Tree1 a = Nil | Node1 a (Tree1 a) (Tree1 a) 

एक द्विआधारी पेड़ जो दो तत्वों को संग्रहीत कर सकता है, और प्रत्येक शाखा एक तत्व (और नील नहीं) के साथ "पत्ती" के साथ समाप्त होती है:

 data Tree2 ab = Leaf2 b | Node2 ab (Tree2 ab) (Tree2 ab) 

एक बाइनरी ट्री जो स्ट्रिंग के डेटा को स्टोर कर सकता है और एक शीट के साथ समाप्त होता है:

 data Tree3 = Leaf3 String | Node3 String Tree3 Tree3 

और, कहते हैं, सूची के दो और प्रकार हैं:
साधारण

 type Lst a = [a] 

और "रस्सी" टाइप करें

 data Rope ab = Nil | Twisted b (Rope ba) 

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


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

 class Size a where size :: a -> Int 

यह केवल (विशिष्ट डेटा प्रकारों के लिए) के विशिष्ट मूल्यों के लिए इस वर्ग के उदाहरण (उदाहरण) बनाने के लिए बना हुआ है:

 instance Size (Tree1 a) where size Nil = 0 size (Node1 _ lr) = 1 + size l + size r instance Size (Tree2 ab) where size (Leaf2 _) = 1 size (Node2 _ _ lr) = 2 + size l + size r instance Size Tree3 where size (Leaf3 m) = length m size (Node3 mlr) = length m + size l + size r instance Size [a] where size = length instance Size (Rope ab) where size Nil = 0 size (Twisted _ ls) = 1 + size ls 

हो गया! अब अगर हम लिखते हैं :t size जीएचसीआई में :t size , हम size :: Size a => a -> Int देखेंगे size :: Size a => a -> Int । हमें वह मिला जो हम चाहते थे:

 size Nil ->> 0 size (Node1 "foo" (Node1 "bar" Nil Nil) Nil) ->> 2 size (Leaf 2 "foo") ->> 1 size (Node3 "foo" (Node3 "bar" (Leaf3 "abc") (Leaf "cba")) (Leaf "tst")) ->> 15 --3*5 size [1..5] ->> 5 size (Rope 2 (Rope 'a' (Rope 5 Nil))) ->> 3 

Size वर्ग का प्रत्येक उदाहरण आकार फ़ंक्शन को लागू करता है, जो केवल एक निश्चित प्रकार (= डेटा संरचनाओं) के मूल्यों पर लागू होता है। इस मामले में, यह फ़ंक्शन, साथ ही साथ अन्य पूर्वनिर्धारित ऑपरेटर (+), (*), (-), अतिभारित है।

लेकिन इस तरह के निर्णय के नुकसान भी हैं। उदाहरण के लिए, हम युग्मित सूची में तत्वों की संख्या जानना चाहते हैं, अर्थात्।

 size [(1,2), (3,4)] ->> 4 size [('a','b'), ('c','d'), ('e','f')] ->> 6 

निम्नलिखित कार्य करना स्पष्ट होगा:

 instance Size [(a,b)] where size = (*2) . length 

लेकिन यहाँ हमारे पास एक समस्या है, क्योंकि हमारे पास पहले से ही सामान्य सूची के लिए एक उदाहरण है ( instance Size [a] where ), हम अब एक अलग परिभाषा का उपयोग नहीं कर सकते हैं, क्योंकि, जैसा कि पहले उल्लेख किया गया है, प्रकार a भी हो सकता है, सहित (b,c) , वह है। [a] == [(b,c)] इस समस्या को हल करने के लिए, आप ओवरलैपिंग इंस्टेंस (अंग्रेजी ओवरलैपिंग क्लास इंस्टेंसेस) का उपयोग कर सकते हैं। इस समाधान में इसकी कमियां हैं (किसी एक मॉड्यूल को आयात करने से कार्यक्रम का मूल्य बदल सकता है, भ्रामक त्रुटियां हो सकती हैं, और इसी तरह)।
अब कक्षाओं के बारे में थोड़ा और।

कक्षाएं

पिछले उदाहरण में, हमने Size वर्ग पास किया था, लेकिन यहाँ हास्केल में अपूर्ण वर्ग घोषणा है: (टीवी = प्रकार चर):

 class Name tv where    tv 

अधूरा है क्योंकि tv पर प्रतिबंधों को वर्ग घोषणा में भी पेश किया जा सकता है (उदाहरण के लिए, tv को Ord क्लास का एक तत्व होना चाहिए)। हस्ताक्षर आपको जितने पसंद हो सकते हैं, लेकिन उनमें से प्रत्येक को चर टीवी के रूप में शामिल करना चाहिए (इनपुट और / या आउटपुट पैरामीटर के रूप में)।
टाइप कक्षाएं उन प्रकारों का संग्रह है जिनके लिए विशेष कार्य परिभाषित किए गए हैं। हास्केल में कुछ (सबसे महत्वपूर्ण) वर्गों में से एक हैं:

• Eq - दो डेटा प्रकार (संचालन ==, / =) की समानता (असमानता) के लिए परीक्षण के लिए वर्ग
• आयु - प्रकार के क्रम को निर्धारित करने के लिए एक वर्ग, जो कि तत्व बड़ा है, जो छोटा है (संचालन>,> =, <, <=, न्यूनतम, अधिकतम ...)
• Enum - उन प्रकारों के लिए एक वर्ग जिसका मान "गिना" जा सकता है (उदाहरण के लिए, [1..10])
• बंधे - बंधे वर्ग का उपयोग Enum वर्ग के प्रकारों के लिए भी किया जाता है। एक प्रकार के निचले और ऊपरी सीमा का नाम दिया गया।
• दिखाएँ - उन प्रकारों के लिए एक वर्ग जिनके मूल्यों को स्ट्रिंग में परिवर्तित किया जा सकता है (= वर्णों के रूप में दर्शाया जा सकता है)
• पढ़ें - उन प्रकारों के लिए एक वर्ग जिनके मूल्यों को एक स्ट्रिंग से परिवर्तित किया जा सकता है

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


आइए समतुल्यता Eq अधिक विस्तार से देखें। जैसा कि पहले उल्लेख किया गया है, इस वर्ग में दो कार्य (==) और (/ =) होने चाहिए:

 class Eq a where (==), (/=) :: a -> a -> Bool --   (==)  (/=) ,     1  x /= y = not (x == y) x == y = not (x /= y) 

कोड बताता है कि Eq वर्ग के किसी भी उदाहरण के लिए, यह दो कार्यों में से एक को लागू करने के लिए पर्याप्त है। उदाहरण के लिए, बूल प्रकार के लिए (दो प्रकार केवल तब ही समान होते हैं, जब वे दोनों सही या गलत होते हैं) इस प्रकार किया जाता है:

 instance Eq Bool where (==) True True = True (==) False False = True (==) _ _ = False 

जैसा कि आप देख सकते हैं, केस ट्रू फ़ल्स एंड फ़ल्स ट्रू (साथ ही अंतिम पंक्ति) लिखने के लिए आवश्यक नहीं है, क्योंकि असमानता समानता का विलोम है। यदि इससे पहले हमारे पास यह मामला था कि प्रकार दूसरे प्रकार का एक cokretization है (उदाहरण के लिए, [Int] प्रकार का उदाहरण है [a]), अब प्रकार वर्ग का एक उदाहरण हो सकता है (उदाहरण के लिए, Bool Eq वर्ग का एक उदाहरण है)। उसी सादृश्य से, हम उन बाइनरी पेड़ों के समानता कार्यों को लिख सकते हैं जो हमने ऊपर उपयोग किए थे। उदाहरण के लिए, ट्री 2 के लिए:

 instance (Eq a) => Eq (Tree2 a) where --   a,      (==) (Leaf2 s) (Leaf2 t) = (s==t) (==) (Node2 s t1 t2) (Node2 t u1 u2)= (s==t) && (t1 == u1) && (t2 == u2) (==) _ _ = False 

(Tree3 ab) हमें पहले से ही a और b दोनों पर एक शर्त लागू करनी होगी, अर्थात्।
instance (Eq a, Eq b) => Eq (Tree3 ab)

प्रतीक के बाईं ओर का सब कुछ => एक संदर्भ कहा जाता है, इस प्रतीक के दाईं ओर सब कुछ या तो आधार प्रकार (इंट, बूल, ...) या टाइप कंस्ट्रक्टर (ट्री ए, [...], ...) होना चाहिए। ऑपरेटर (==) एक अतिभारित फ़ंक्शन (तदर्थ बहुरूपता) है।

समानता (==) एक प्रकार पर निर्भर संपत्ति है जिसे प्रत्येक प्रकार के लिए कार्यान्वयन की आवश्यकता होती है (जैसे कि बाइनरी पेड़ों की समानता का कार्यान्वयन)। मैं इस तरह से दो कार्यों की तुलना करने में सक्षम होना चाहूंगा:

 (==) fac fib ->> False -- fac -  ,  fib -   (==) (\x -> x+x) (\x -> 2*x) ->> True (==) (+2) (2+) ->> True 

इसके लिए हास्केल में ऐसा कोड लिखने की आवश्यकता होगी:

 instace Eq (Int -> Int) where (==) fg = ... -- f  g  -  

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

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

 data Tree a = Nil | Node a (Tree a) (Tree a) deriving Eq 

यह हमें अपने हाथों से Eq वर्ग का उदाहरण लिखने की अनुमति नहीं देता है ( instance Eq a => Eq (Tree a) where ... )। लेकिन किसी भी फ़ंक्शन के लिए, फिर चर पर एक शर्त लागू करना आवश्यक a कि यह चर वर्ग ईक का एक तत्व है। कभी-कभी, आखिरकार, आपको इन कार्यों को स्वयं लिखना होगा, क्योंकि "स्वचालित" तुलना हमेशा काम नहीं करती है जैसा हम चाहते हैं। उदाहरण के लिए एक बाइनरी ट्री के लिए

 data Tree3 ab = Leaf3 bl | Node3 ab (Tree3 ab) (Tree3 ab) deriving Eq 

निम्नलिखित फ़ंक्शन को स्वचालित रूप से लागू किया जाएगा:

 instance (Eq a, Eq b) => Eq (Tree3 ab) where (==) (Leaf3 q) (Leaf3 s) = (q==s) (==) (Node3 _ q t1 t2) (Node3 _ s u1 u2) = (q==s)&&(t1==u1)&&(t2==u2) (==) _ _ = False 

जैसा कि हम देख सकते हैं, Node3 का पहला तर्क छोड़ दिया गया था, जिसे हम कुछ मामलों में नहीं चाहेंगे।

निष्कर्ष

दो प्रकार के बहुरूपता के बीच एक अनौपचारिक अंतर:

• पैरामीट्रिक - समान प्रकार की परवाह किए बिना समान कोड।
• तदर्थ - विभिन्न कोड, हालांकि एक ही फ़ंक्शन नाम।