टाइप फैमिलीज एंड पोकेमॉन

प्रस्तावना

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



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

हम पोकेमॉन दुनिया का हिस्सा एक सीमित (और यहां तक ​​कि कुछ हद तक सरलीकृत, प्रशंसकों को मुझे माफ करने दें) को प्रस्तुत करने के लिए हास्केल का उपयोग करने जा रहे हैं। अर्थात्:

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

पहला प्रयास

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

data Fire = Charmander | Charmeleon | Charizard deriving Show data Water = Squirtle | Wartortle | Blastoise deriving Show data Grass = Bulbasaur | Ivysaur | Venusaur deriving Show data FireMove = Ember | FlameThrower | FireBlast deriving Show data WaterMove = Bubble | WaterGun deriving Show data GrassMove = VineWhip deriving Show pickFireMove :: Fire -> FireMove pickFireMove Charmander = Ember pickFireMove Charmeleon = FlameThrower pickFireMove Charizard = FireBlast pickWaterMove :: Water -> WaterMove pickWaterMove Squirtle = Bubble pickWaterMove _ = WaterGun pickGrassMove :: Grass -> GrassMove pickGrassMove _ = VineWhip 

अब तक अच्छा है, टाइप चेकर यह पता लगाने में मदद करता है कि कौन सा पोकेमॉन अपने तत्व का सही उपयोग करता है।


हमारे द्वारा वर्णित 9 पोकेमोन में से 6 सभी तीन तत्वों के हैं। प्रत्येक प्रकार के लिए 2

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

 printBattle :: String -> String -> String -> String -> String -> IO () printBattle pokemonOne moveOne pokemonTwo moveTwo winner = do putStrLn $ pokemonOne ++ " used " ++ moveOne putStrLn $ pokemonTwo ++ " used " ++ moveTwo putStrLn $ "Winner is: " ++ winner ++ "\n" 

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

 battleWaterVsFire :: Water -> Fire -> IO () battleWaterVsFire water fire = do printBattle (show water) moveOne (show fire) moveTwo (show water) where moveOne = show $ pickWaterMove water moveTwo = show $ pickFireMove fire battleFireVsWater = flip battleWaterVsFire --   ,   ,   ,    

यदि हम यह सब जोड़ते हैं और झगड़े के अन्य कार्यों को जोड़ते हैं, तो हमें एक कार्यक्रम मिलेगा।

टाइप क्लासेस का परिचय

कितना दोहराया कोड है: कल्पना करें कि कोई पोकेमोन इलेक्ट्रिक तत्व को जोड़ना चाहता था, उदाहरण के लिए पिकाचु, तो आपको अपना खुद का battleElectricVs(Grass|Fire|Water) जोड़ना battleElectricVs(Grass|Fire|Water) झगड़े। ऐसे कई टेम्पलेट हैं जो हमें औपचारिक बनाने में मदद करेंगे और लोगों को यह समझने में मदद करेंगे कि पोकेमॉन क्या है और नए लोगों को कैसे जोड़ा जाए।
हमारे पास क्या है:

• पोकेमॉन आंदोलन का चयन करने के लिए कार्यों का उपयोग करता है
• लड़ाई में एक विजेता मिलता है और लड़ाई का विवरण छापता है

हम औपचारिकता के लिए कई प्रकार की कक्षाओं को परिभाषित करेंगे, और एक बार जब हम शासन करेंगे, तो हम अब असामान्य नाम योजना का भी नाम बदल देंगे, जहां प्रत्येक फ़ंक्शन में वह तत्व शामिल है जिसके साथ वह संचालित होता है।

नि वर्ग

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

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

 class (Show pokemon, Show move) => Pokemon pokemon move where pickMove :: pokemon -> move instance Pokemon Fire FireMove where pickMove Charmander = Ember pickMove Charmeleon = FlameThrower pickMove Charizard = FireBlast instance Pokemon Water WaterMove where pickMove Squirtle = Bubble pickMove _ = WaterGun instance Pokemon Grass GrassMove where pickMove _ = VineWhip 

और हम फ़ंक्शन का उपयोग इस तरह कर सकते हैं

 pickMove Charmander :: FireMove 

ध्यान दें कि चीजें कैसी दिखनी शुरू होती हैं। इस तथ्य के कारण कि पोकेमॉन तत्वों और प्रकार के आंदोलन को स्वतंत्र रूप से टाइप कक्षाओं द्वारा संसाधित किया जाता है। यह कहते हुए कि हम फायर स्ट्राइक चुनते हैं, हम टाइप इंस्पेक्टर को सारी जानकारी देते हैं ताकि वह यह तय करे कि किस क्लास और स्ट्रोक का इस्तेमाल करना है।

लड़ाई का वर्ग

हमारे पास पहले से ही पोकेमोन हैं जो अपने स्वयं के घूंसे चुन सकते हैं, अब हमें एक अमूर्त की आवश्यकता है, जो दो पोकेमोन की लड़ाई का प्रतिनिधित्व करेगा, ताकि लड़ाई से छुटकारा पाने के लिए battle*family*Vs*family जैसे कार्यों से छुटकारा मिल सके।
हम वास्तव में इस तरह कोड लिखना चाहेंगे:

 class (Pokemon pokemon move, Pokemon foe foeMove) => Battle pokemon move foe foeMove where battle :: pokemon -> foe -> IO () battle pokemon foe = do printBattle (show pokemon) (show move) (show foe) (show foeMove) (show pokemon) where move = pickMove pokemon foeMove = pickMove foe instance Battle Water WaterMove Fire FireMove 

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

 battle :: pokemon -> foe -> IO (move, foeMove) 

प्रकार परिवारों का परिचय, अंत में!

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

पोकेमॉन वर्ग प्रकार परिवारों का उपयोग करते हुए

टाइप TypeFamilies का उपयोग करने के लिए, हमें TypeFamilies एक्सटेंशन को सक्षम करना TypeFamilies । जैसे ही हम प्लग करते हैं, हम अपनी कक्षा को इस शैली में लिखने का प्रयास कर सकते हैं:

 {-# LANGUAGE TypeFamilies, FlexibleContexts #-} class (Show p, Show (Move p)) => Pokemon p where data Move p :: * pickMove :: p -> Move p 

हमने अपने पोकेमॉन क्लास को इस तरह से परिभाषित किया है कि इसमें एक तर्क और एक संबद्ध प्रकार का आंदोलन है। आंदोलन का प्रकार एक "प्रकार का कार्य" बन जाता है जो उपयोग किए जाने वाले स्ट्रोक के प्रकार को लौटाता है। इसका मतलब यह है कि हम WaterMove बजाय Move Fire उपयोग करेंगे, WaterMove स्थान पर Move Water , आदि
ध्यान दें कि निर्भरता लगभग पिछले मामले की तरह ही दिखती है, केवल Show move बजाय हम Show (Move a)) उपयोग करते हैं। हमें इसके साथ काम करने के लिए एक और जोड़ शामिल करना होगा: FlexibleContexts ।
अब हास्केल हमें उत्कृष्ट सिंटैक्टिक चीनी प्रदान करता है, इसलिए जब हम अपने उदाहरण को परिभाषित करते हैं तो हम दाईं ओर वास्तविक संबद्ध डेटा कंस्ट्रक्टर को परिभाषित कर सकते हैं।
आइए हमारे सभी डेटा प्रकारों को फिर से परिभाषित करें और टाइप परिवारों का उपयोग करके आवश्यक वर्ग उदाहरण बनाएं।

 data Fire = Charmander | Charmeleon | Charizard deriving Show instance Pokemon Fire where data Move Fire = Ember | FlameThrower | FireBlast deriving Show pickMove Charmander = Ember pickMove Charmeleon = FlameThrower pickMove Charizard = FireBlast data Water = Squirtle | Wartortle | Blastoise deriving Show instance Pokemon Water where data Move Water = Bubble | WaterGun deriving Show pickMove Squirtle = Bubble pickMove _ = WaterGun data Grass = Bulbasaur | Ivysaur | Venusaur deriving Show instance Pokemon Grass where data Move Grass = VineWhip deriving Show pickMove _ = VineWhip 

अब हम सुरक्षित रूप से लिख सकते हैं

 pickMove Squirtle 

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

न्यू बैटल क्लास

अब लंबे हस्ताक्षर की आवश्यकता नहीं है, इसलिए आप घृणित बैसाखी को हटा सकते हैं, और लगभग मूल मूल्य वापस कर सकते हैं।

 class (Pokemon pokemon, Pokemon foe) => Battle pokemon foe where battle :: pokemon -> foe -> IO () battle pokemon foe = do printBattle (show pokemon) (show move) (show foe) (show foeMove) (show pokemon) where foeMove = pickMove foe move = pickMove pokemon 

और, तुम, अब लड़ाई अब हमलों के बारे में कुछ भी जानने की जरूरत नहीं है। और पोकेमोन को पीटते हुए लगभग भोली के रूप में एक जैसा दिखता है।

 instance Battle Water Fire instance Battle Fire Water where battle = flip battle instance Battle Grass Water instance Battle Water Grass where battle = flip battle instance Battle Fire Grass instance Battle Grass Fire where battle = flip battle 

उपयोग करना भी सरल है:

  battle Squirtle Charmander 

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

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

ठीक है, चलो पोकेमॉन वर्ल्ड में एक और चीज जोड़ते हैं।
अब हमने अपने Water और Fire तत्वों को Battle Water Fire रूप में पहचाना है, और फिर Battle Water Fire पिछले वाले के समान है, जिसमें तर्कों की अदला-बदली है। पहला Pokemon हमेशा जीतता है, और निम्नलिखित हमेशा आउटपुट होता है:

 -- Winner Pokemon move -- Loser Pokemon move -- Winner pokemon Wins. 

यहां तक ​​कि जब उदाहरण में पहले हारने वाला होता है, तब भी विजेता सबसे पहले स्क्रीन पर प्रदर्शित होगा।
आइए इसे प्रतिस्थापित करें, और नमूनों को तय करने दें कि लड़ाई कौन जीतता है, और हम प्राप्त कर सकते हैं

 -- Loser Pokemon move -- Winner Pokemon move -- Winner pokemon Wins 

एसोसिएटेड टाइप समानार्थी

जब हम दो प्रकारों की पसंद को वापस करने का निर्णय लेते हैं, तो हम आमतौर पर Either ab उपयोग करते हैं, लेकिन यह रन टाइम में है, लेकिन हम चाहते हैं कि टाइप चेकर यह सुनिश्चित करें कि जब तत्वों में आग और पानी की लड़ाई हो, तो पानी हमेशा विजेता होगा।
इसलिए, हम लड़ाई में एक नया फ़ंक्शन जोड़ेंगे और इसे विजेता का नाम देंगे, जो कि उसी क्रम में 2 तर्क प्राप्त करेंगे जो लड़ाई फ़ंक्शन द्वारा प्राप्त किए गए थे, और तय करेंगे कि कौन जीतेगा।
हालाँकि, कई विकल्पों में से एक को वापस लेने से विजेता के हस्ताक्षर का चुनाव अनिश्चित हो जाता है।

 class Battle pokemon foe where .. winner :: pokemon -> foe -> ??? --   , 'pokemon'  'foe'? instance Battle Water Fire where winner :: Water -> Fire -> Water -- Water    : pokemon winner water _ = water instance Battle Fire Water where winner :: Fire -> Water -> Water -- Water   : foe winner _ water = water 

आप देखते हैं, Battle Water Fire उदाहरण के लिए, विजेता प्रकार pokemon के समान है, और Battle Fire Water यह पहले से ही foe ।

सौभाग्य से, टाइप परिवार भी संबंधित प्रकार के समानार्थक शब्द का समर्थन करते हैं। बैटल क्लास में, हमारे पास एक Winner pokemon foo , और उदाहरणों में हम यह निर्धारित करेंगे कि उनमें से कौन सा होगा। हम एक प्रकार का उपयोग करते हैं, डेटा का नहीं, क्योंकि यह केवल pokemon या foe लिए एक पर्याय है।
Winner एक प्रकार का हस्ताक्षरित प्रकार का कार्य है * -> * -> * , जो pokemon और foo दोनों प्राप्त करता है, और उनमें से एक को वापस करता है।
हम एक डिफ़ॉल्ट कार्यान्वयन को भी परिभाषित करेंगे जो pokemon चयन करेगा

 class (Show (Winner pokemon foe), Pokemon pokemon, Pokemon foe) => Battle pokemon foe where type Winner pokemon foe :: * --    type Winner pokemon foe = pokemon --      battle :: pokemon -> foe -> IO () battle pokemon foe = do printBattle (show pokemon) (show move) (show foe) (show foeMove) (show winner) where foeMove = pickMove foe move = pickMove pokemon winner = pickWinner pokemon foe pickWinner :: pokemon -> foe -> (Winner pokemon foe) 

उदाहरण निम्नानुसार बनाए गए हैं:

 instance Battle Water Fire where pickWinner pokemon foe = pokemon instance Battle Fire Water where type Winner Fire Water = Water pickWinner = flip pickWinner 

अब बस इतना ही।
कार्यक्रम का अंतिम संस्करण इस प्रकार है:

अब आप अपनी खुद की Electric Pokemon जोड़ सकते हैं! इसे आजमाइए!

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