लेंस का उपयोग करके हास्केल में अनिवार्य रूप से प्रोग्रामिंग करना

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

लेंस

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

 data Game = Game { _score :: Int , _units :: [Unit] , _boss :: Unit } deriving (Show) 

प्राणियों से भरा (यूनिट):

 data Unit = Unit { _health :: Int , _position :: Point } deriving (Show) 

जिनके स्थान बिंदुओं से निर्धारित होते हैं:

 data Point = Point { _x :: Double , _y :: Double } deriving (Show) 

हम खेतों में एक अंडरस्कोर जोड़ते हैं क्योंकि हम उन्हें सीधे उपयोग नहीं करेंगे। इसके बजाय, हम उन लेंसों का निर्माण करने के लिए उनका उपयोग करेंगे जिनके साथ काम करने के लिए बहुत अधिक सुखद है।

हम दो तरीकों से लेंस का निर्माण कर सकते हैं। पहला विकल्प Control.Lens lens से सुविधाजनक lens फ़ंक्शन का उपयोग करके मैन्युअल रूप से लेंस बनाना है। उदाहरण के लिए, हम _score फ़ील्ड के लिए score लेंस को इस प्रकार परिभाषित कर सकते हैं:

 import Control.Lens score :: Lens' Game Int score = lens _score (\game v -> game { _score = v }) 

Lens जटिल डेटा प्रकार नेविगेट करने के लिए एक नक्शे के रूप में टाइप करते हैं। हम _score Game को _score से प्राप्त करने के लिए score लेंस का उपयोग करते हैं।
प्रकार यह दर्शाता है कि हमें कहाँ शुरू करना चाहिए और कैसे समाप्त होना चाहिए: Lens' Game Int अर्थ है कि हमें Game शुरू करना चाहिए और अंत में (हमारे मामले में _score फ़ील्ड के लिए) होना चाहिए। इसी तरह, हमारे अन्य लेंस स्पष्ट रूप से उनके प्रकारों की शुरुआत और अंत बिंदुओं को दर्शाते हैं:

 units :: Lens' Game [Unit] units = lens _units (\game v -> game { _units = v }) boss :: Lens' Game Unit boss = lens _boss (\game v -> game { _boss = v }) health :: Lens' Unit Int health = lens _health (\unit v -> unit { _health = v }) position :: Lens' Unit Point position = lens _position (\unit v -> unit { _position = v }) x :: Lens' Point Double x = lens _x (\point v -> point { _x = v }) y :: Lens' Point Double y = lens _y (\point v -> point { _y = v }) 

हालांकि, हम अक्सर आलसी होते हैं और नियमित कोड लिखना नहीं चाहते हैं। इस मामले में, आप Template Haskell का उपयोग करके एक अलग रास्ता चुन सकते हैं ताकि यह हमारे लिए लेंस Template Haskell :

 {-# LANGUAGE TemplateHaskell #-} import Control.Lens data Game = Game { _score :: Int , _units :: [Unit] , _boss :: Unit } deriving (Show) data Unit = Unit { _health :: Int , _position :: Point } deriving (Show) data Point = Point { _x :: Double , _y :: Double } deriving (Show) makeLenses ''Game makeLenses ''Unit makeLenses ''Point 

बस याद रखें, पैटर्न वाले हसेल डेटा प्रकार की घोषणा के बाद makeLenses वाले मेक्लिम्स घोषणा को ट्रम्पेट करता है।

प्रारंभिक अवस्था

अगली चीज़ जो हमें करने की ज़रूरत है वह है खेल की प्रारंभिक अवस्था।

हमने तीन नायक बनाए, जो कालकोठरी मालिक के खिलाफ लड़ेंगे। लड़ाई शुरू करते हैं!

पहला कदम

अब हम अपने लेंस का उपयोग कर सकते हैं! चलो हमारे योद्धाओं के लिए बॉस पर हमला करने के लिए एक फ़ंक्शन बनाएं।

 import Control.Monad.Trans.Class import Control.Monad.Trans.State strike :: StateT Game IO () strike = do lift $ putStrLn "*shink*" boss.health -= 10 

strike फ़ंक्शन कंसोल में हमें एक समान ध्वनि प्रिंट करता है, फिर बॉस 10 स्वास्थ्य इकाइयों के स्वास्थ्य को कम करता है।
हमले के प्रकार हमें दिखाते हैं कि हम StateT Game IO साथ काम कर रहे हैं। आप सोच सकते हैं कि यह एक ऐसी एम्बेडेड भाषा है, जहां हम साइड इफेक्ट्स (यानी IO ) के शीर्ष पर शुद्ध गेम स्टेट्स (यानी StateT Game ) की एक परत बनाते हैं ताकि हम एक साथ राज्यों को बदल सकें और कंसोल पर लड़ाई से हमारे सबसे प्यारे प्रभावों को प्रिंट कर सकें। । अब हमें केवल यह याद रखना चाहिए कि यदि हम साइड इफेक्ट्स का उपयोग करना चाहते हैं, तो हमें lift फ़ंक्शन का उपयोग करना होगा।
आइए इंटरप्रेटर ( ghci ) में हमारे फ़ंक्शन का उपयोग करने का प्रयास करें। ऐसा करने के लिए, हमें प्रारंभिक अवस्था की आवश्यकता है:

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

 >>> newState <- execStateT strike initialState *shink* 

और फिर हम इसमें से आवश्यक जानकारी निकालेंगे:

 >>> newState^.boss.health 90 

रचना

निम्न कोड बहुत जरूरी और वस्तु-उन्मुख कोड जैसा दिखता है:

 boss.health -= 10 

यहाँ क्या हो रहा है ?? हास्केल निश्चित रूप से एक बहु-प्रतिमान भाषा नहीं है, लेकिन हमारे पास बहु-प्रतिमान कोड में दिखाई देता है।
अविश्वसनीय रूप से, इस कोड में कुछ भी भाषा में निर्मित एक विशेषता नहीं है!

• boss और health सिर्फ लेंस हैं जिन्हें हमने ऊपर परिभाषित किया है
• (-=) - इन्फिक्स फ़ंक्शन
• (.) - हास्कल Prelude से एक कार्यात्मक रचना!

रुको, (.) क्या यह एक कार्यात्मक रचना है? सच में!
यह वह जगह है जहां सभी लेंस जादू होता है। लेंस सबसे आम कार्य हैं, और हमारे सभी "बहु-प्रतिमान" कोड वास्तव में कार्यों के मिश्रण से अधिक कुछ नहीं है!

वास्तव में, Lens' ab प्रकार उच्च-क्रम के कार्यों का एक पर्याय है:

 type Lens' ab = forall f . (Functor f) => (b -> fb) -> (a -> fa) 

अब आपको सब कुछ समझने की जरूरत नहीं है। बस याद रखें कि Lens' ab एक उच्च क्रम फ़ंक्शन है जो इनपुट तर्क के रूप में टाइप (b -> fb) लेता है और प्रकार का एक नया फ़ंक्शन (a -> fa) लौटाता है। Functor एक सिद्धांत का हिस्सा है जिसे अब "जादू" के रूप में देखा जा सकता है।

यह इस प्रकार है कि लेंस की संरचना भी एक लेंस है! वास्तव में, लेंस एक श्रेणी बनाते हैं, जहां (.) श्रेणीबद्ध रचना ऑपरेटर है, और पहचान फ़ंक्शन id भी एक लेंस है:

 (.) :: Lens' xy -> Lens' yz -> Lens' xz id :: Lens' xx 

नतीजतन, इस तथ्य का उपयोग करते हुए कि आप ऑपरेटर के पास रिक्त स्थान निकाल सकते हैं, हमें एक कोड मिलता है जो ऑब्जेक्ट-ओरिएंटेड कोड के अंकन की तरह दिखता है!

श्रेणियाँ उड़ने पर समूह घटकों को जोड़ने और अविश्वसनीय रूप से आसान बनाती हैं। उदाहरण के लिए, यदि हम बॉस के स्वास्थ्य में बार-बार बदलाव की उम्मीद करते हैं, तो हम लेंस की संरचना निर्धारित कर सकते हैं:

 bossHP :: Lens' Game Int bossHP = boss.health 

और अब हम इसका उपयोग कर सकते हैं जहाँ भी boss.health ।

 strike :: StateT Game IO () strike = do lift $ putStrLn "*shink*" bossHP -= 10 

और स्वास्थ्य का एक नया अर्थ भी खोजें:

 >>> newState^.bossHP 90 

Perecheslimye

लेंस एक बहुत ही सुंदर सिद्धांत पर आधारित हैं, और इसके परिणामस्वरूप हमें वह मिलता है जो सबसे अधिक अनिवार्य भाषाएं बस नहीं कर सकती हैं!

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

 fireBreath :: StateT Game IO () fireBreath = do lift $ putStrLn "*rawr*" units.traversed.health -= 3 

यह लेंस के साथ नए तरीके से काम करना संभव बनाता है!

 traversed :: Traversal' [a] a 

traversed हमें सूची में मानों के "नीचे से ऊपर" तक पहुंचने में मदद करता है ताकि हम पूरी सूची को मैन्युअल रूप से ट्रैवर्स करने के बजाय इसके साथ काम कर सकें। हालाँकि, इस बार हम Traversal' प्रकार का उपयोग Traversal' Lens' बजाय Lens' ।

Traversal' एक ही Lens' , केवल कमजोर:

 type Traversal' ab = forall f . (Applicative f) => (b -> fb) -> (a -> fa) 

यदि हम Traversal' और Lens' की रचना करते हैं, तो हमें एक कमजोर प्रकार मिलता है, जिसका नाम Traversal' । यह उस आदेश की परवाह किए बिना काम करता है जिसमें हम गठबंधन करते हैं:

 (.) :: Lens' ab -> Traversal' bc -> Traversal' ac (.) :: Traversal' ab -> Lens' bc -> Traversal' ac units :: Lens' Game [Unit] units.traversed :: Traversal' Game Unit units.traversed.health :: Traversal' Game Int 

वास्तव में, हमें यह जानने की भी आवश्यकता नहीं है। कंपाइलर सही प्रकार से स्वयं पता लगाएगा:

 >>> :t units.traversed.health units.traversed.health :: Applicative f => (Int -> f Int) -> Game -> f Game 

यह Traversal' Game Int की परिभाषा से बिल्कुल मेल खाता है!

दरअसल, हम इन दोनों लेंसों को एक में क्यों नहीं मिलाते हैं?

 partyHP :: Traversal' Game Int partyHP = units.traversed.health fireBreath :: StateT Game IO () fireBreath = do lift $ putStrLn "*rawr*" partyHP -= 3 

आइए स्वास्थ्य के नए अर्थ का पता लगाने के लिए partyHP फ़ंक्शन का उपयोग करें:

 >>> newState <- execStateT fireBreath initialState *rawr* >>> newState^.partyHP <interactive>:3:11: No instance for (Data.Monoid.Monoid Int) arising from a use of `partyHP' ......... 

ऊप्स! यह एक प्रकार की गलती है, क्योंकि हमें स्वास्थ्य का एकमात्र मूल्य नहीं मिल सकता है! यही कारण है कि Traversal' Lens' तुलना में कमजोर Lens' : बायपास कई मूल्यों को इंगित कर सकते हैं, इसलिए वे एकल मूल्य दिखाने के लिए एक अच्छी तरह से परिभाषित तरीके का समर्थन नहीं करते हैं। सिस्टम ने हमें एक संभावित बग से छुटकारा पाने में मदद की।

इसके बजाय, हमें यह निर्धारित करना चाहिए कि हम सूची का उपयोग करके सूची प्राप्त करना चाहते हैं:

 toListOf :: Traversal' ab -> a -> [b] 

यह हमें एक संतोषजनक परिणाम देता है:

 >>> toListOf partyHP newState [7,12,5] 

या toListOf फ़ंक्शन के बराबर toListOf : (^..) :

 >>> initialState^..partyHP [10,15,8] >>> newState^..partyHP [7,12,5] 

इससे हमें यह स्पष्ट रूप से पता चलता है कि हमें वह चीज मिली जो हम fireBreath साथ चाहते थे।

और चलो वास्तव में कुछ फैंसी मिलता है। हम भौगोलिक क्षेत्र द्वारा सूची निर्धारण कर सकते हैं। क्या हम कर सकते हैं?

 around :: Point -> Double -> Traversal' Unit Unit around center radius = filtered (\unit -> (unit^.position.x - center^.x)^2 + (unit^.position.y - center^.y)^2 < radius^2 ) 

बेशक हम कर सकते हैं! हम सर्कल में आग की सांस को सीमित करने में सक्षम थे!
filtered वास्तव में सैद्धांतिक रूप से गणना योग्य नहीं है क्योंकि यह तत्वों की संख्या को संग्रहीत नहीं करता है

 fireBreath :: Point -> StateT Game IO () fireBreath target = do lift $ putStrLn "*rawr*" units.traversed.(around target 1.0).health -= 3 

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

किसी भी मामले में, चलो आग बुझाने की कल पर वापस जाएं। पहले, आइए देखें कि उसके बाद कौन है:

 > initialState^..units.traversed.position [Point {_x = 3.5, _y = 7.0},Point {_x = 1.0, _y = 1.0},Point {_x = 0.0, _y = 2.1}] 

हम्म, दो योद्धा एक-दूसरे के करीब हैं। चलो वहाँ एक आग का गोला फेंक

 >>> newState <- execStateT (fireBreath (Point 0.5 1.5)) initialState *rawr* >>> (initialState^..partyHP, newState^..partyHP) ([10,15,8],[10,12,5]) 

समझ गया!

स्केलिंग

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

 retreat :: StateT Game IO () retreat = do lift $ putStrLn "Retreat!" zoom (units.traversed.position) $ do x += 10 y += 10 

पहले की तरह, हम दो लेंसों को एक में जोड़ सकते हैं यदि हम अभी भी उनका उपयोग करने जा रहे हैं:

 partyLoc :: Traversal' Game Point partyLoc = units.traversed.position retreat :: StateT Game IO () retreat = do lift $ putStrLn "Retreat!" zoom partyLoc $ do x += 10 y += 10 

अच्छा, चलो कोशिश करते हैं!

 >>> initialState^..partyLoc [Point {_x = 3.5, _y = 7.0},Point {_x = 1.0, _y = 1.0},Point {_x = 0.0, _y = 2.1}] >>> newState <- execStateT retreat initialState Retreat! >>> newState^..partyLoc [Point {_x = 13.5, _y = 17.0},Point {_x = 11.0, _y = 11.0},Point {_x = 10.0, _y = 12.1}] 

आइए हमारे संदर्भ में स्केलिंग के प्रकार को करीब से देखें:

 zoom :: Traversal ab -> StateT b IO r -> StateT a IO r 

zoom फ़ंक्शन में कुछ महान सैद्धांतिक संभावनाएं हैं। उदाहरण के लिए, हम उम्मीद करते हैं कि स्केल किए गए 2x लेंस की संरचना को उनकी रचनाओं के स्केलिंग के समान परिणाम देना चाहिए।

 zoom lens1 . zoom lens2 = zoom (lens1 . lens2) 

और वह खाली लेंस खुद को स्केलिंग देगा:

 zoom id = id 

दूसरे शब्दों में, zoom फ़ंक्शन एक फ़नकार है, जिसका अर्थ है कि यह फ़नकार के नियमों का पालन करता है!

टीमों का संयोजन

इससे पहले, हम एक समय में एक टीम को देखते थे, लेकिन अब अवधारणाओं को संयोजित करते हैं और पात्रों के बीच लड़ाई को अनिवार्य रूप से सेट करते हैं:

 battle :: StateT Game IO () battle = do -- ! forM_ ["Take that!", "and that!", "and that!"] $ \taunt -> do lift $ putStrLn taunt strike --  ! fireBreath (Point 0.5 1.5) replicateM_ 3 $ do --  ! retreat --    zoom (boss.position) $ do x += 10 y += 10 

अच्छा, चलिए!

 >>> execStateT battle initialState Take that! *shink* and that! *shink* and that! *shink* *rawr* Retreat! Retreat! Retreat! Game {_score = 0, _units = [Unit {_health = 10, _position = Poin t {_x = 33.5, _y = 37.0}},Unit {_health = 12, _position = Point {_x = 31.0, _y = 31.0}},Unit {_health = 5, _position = Point {_x = 30.0, _y = 32.1}}], _boss = Unit {_health = 70, _position = P oint {_x = 30.0, _y = 30.0}}} 

मुझे लगता है कि लोग वास्तव में मजाक नहीं कर रहे हैं जब वे कहते हैं कि हास्केल सबसे अच्छा अनिवार्य भाषा है!

निष्कर्ष

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