हास्केल, जैसा कि कुछ बहुत करीब है, या गितुब आपी से काम करता है

बहुत देर से - 'क्योंकि मुझे अब मिल गया है
चारों तरफ भिक्षु हैं
IO, राज्य और सूचियाँ लाजिमी है
यह आसान है, जैसे उन लोगों का कहना है
लेकिन मेरा कार्यक्रम दूर हो गया!
शायद - ऊ,
यह एक सन्यासी भी है, मुझे पता है
मुझे किसी अन्य भाषा का उपयोग क्यों करना चाहिए?

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

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

मेरा मानना ​​है कि यह चरणों में हल करने के लायक है, तो चलिए शुरू की स्थिति से शुरू करते हैं, अर्थात्, फ़ाइल सिस्टम में एक खाली निर्देशिका।

मॉड्यूल निर्माण

शुरू करने के लिए, हमारे उद्देश्यों के लिए एक नया मॉड्यूल बनाएं।

cabal init 

एक पूछताछ करने वाला केबल कुछ सवाल पूछेगा, और परिणामस्वरूप आपको कॉन्फ़िगरेशन फ़ाइल project_name.cabal के साथ एक मॉड्यूल रिक्त मिलेगा । अधिक सौंदर्यशास्त्र के लिए, मॉड्यूल में src निर्देशिका जोड़ें, और इसे कॉन्फ़िगरेशन में निर्दिष्ट करें

 executable project-name hs-source-dirs: src main-is: Main.hs 

बेशक, Main.hs बनाने की जरूरत है)

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

दरअसल, इसका उपयोग करने के लिए सैंडबॉक्स को इनिशियलाइज़ करना और निर्भरता स्थापित करना आवश्यक है

 cabal sandbox init cabal install --only-dependencies 

भविष्य में, मॉड्यूल का निर्माण करने के लिए, आप हमेशा की तरह, कमांड का उपयोग कर सकते हैं

 cabal build 

यदि किसी चीज़ को डिबग करने की तीव्र इच्छा है, और वास्तव में, यह देखने के लिए कि यह अंदर से कैसे काम करता है (और, शैली के नियमों के अनुसार, ऐसी इच्छा अनिवार्य रूप से उत्पन्न होगी), तो आप कमांड द्वारा बनाए गए सैंडबॉक्स में घी चला सकते हैं

 cabal repl 

सब कुछ, एक खाली कैटलॉग का डर खत्म हो गया है, हम आगे बढ़ते हैं।

http-नाली

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

सबसे पहले, कॉन्फ़िगरेशन फ़ाइल के निर्माण-निर्भर अनुभाग के लिए आवश्यक निर्भरताएं जोड़ें।

 bytestring >= 0.10, conduit >= 1.0, http-conduit >= 1.9, 

और ऊपर वर्णित कमांड के साथ सैंडबॉक्स को अपडेट करें।

अब हम उत्सुकता से कोड के लिए आगे बढ़ सकते हैं। शुरू करने के लिए, अपने जीवन को आसान बनाने और तार के साथ काम करने के लिए, हम विस्तार जोड़ते हैं

 {-# LANGUAGE OverloadedStrings #-} 

हम आवश्यक मॉड्यूल कनेक्ट करते हैं

 import Data.Conduit import Network.HTTP.Conduit import qualified Data.Conduit.Binary as CB import qualified Data.ByteString.Char8 as BS 

सभी json डाउनलोड कोड कुछ इस तरह दिखाई देंगे

 main = do manager <- newManager def req <- parseUrl "https://api.github.com/../.." let headers = requestHeaders req req' = req { requestHeaders = ("User-agent", "some-app") : headers } runResourceT $ do res <- http req' manager responseBody res $$+- CB.lines =$ parserSink 

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

 parserSink :: Sink BS.ByteString (ResourceT IO) () parserSink = do md <- await case md of Nothing -> return () Just d -> parseCommits d 

यदि सफल होता है, तो स्टॉक केवल प्राप्त जोंस को पार्स करेगा और इसे स्क्रीन पर प्रदर्शित करेगा (जादू का यह भाग पार्सेकमेट्स फ़ंक्शन में छिपा हुआ है)।

Aeson

हम प्रोग्रामर की सोच को विकृत करते हैं और पार्स करने के लिए आगे बढ़ते हैं। उसके लिए, हम Aeson नामक एक अत्यंत शक्तिशाली पैकेज का उपयोग करेंगे। वास्तव में, यहां सब कुछ काफी सरल है, लेकिन कुछ बिंदु हैं जो आदत से बाहर हैं, एक स्तूप में प्रवेश करें:

• क्योंकि चूंकि हास्केल दृढ़ता से टाइप किया गया है, इसलिए हमें उन प्रकारों की आवश्यकता है जो कि जसन में एम्बेडेड डेटा संरचना का वर्णन करेंगे
• अगर मैंने कुछ भी नहीं मिलाया, तो ऐसन आलसी बायस्ट्रिंग का उपयोग करता है, जबकि सख्त बाईट्रस्टिंग नाली में है, इसलिए आपको प्रकार के साथ करतब दिखाने होंगे

तो, पहले हम प्रकारों को परिभाषित करते हैं। आप परेशान नहीं कर सकते हैं, और केवल आंशिक रूप से उन्हें निर्धारित करते हैं, कुछ जानकारी को जौन से भट्ठी में भेजते हैं। हम केवल url, हैश और कमिट मैसेज छोड़ेंगे।

 import qualified Data.ByteString.Char8 as BS import Data.Aeson (FromJSON(..)) data CommitInfo = CommitInfo { message :: BS.ByteString } deriving (Show) data Commit = Commit { sha :: BS.ByteString, url :: BS.ByteString, commit :: CommitInfo } deriving (Show) 

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

 {-# LANGUAGE DeriveGeneric #-} import GHC.Generics (Generic) 

और मौजूदा डेटा संरचनाओं में जेनेरिक वंशानुक्रम जोड़ें

 deriving(Show, Generic) 

यह केवल json से कमिट और कमिटइन्फो बनाने की संभावना की घोषणा करने के लिए बना हुआ है

 instance FromJSON Commit instance FromJSON CommitInfo 

फिनिश लाइन के कुछ ही कदम, हम लगभग वहाँ हैं

 parseCommits :: BS.ByteString -> Sink BS.ByteString (ResourceT IO) () parseCommits rawData = do let parsedData = decode $ BL.fromChunks [rawData] :: Maybe [Models.Commit] case parsedData of Nothing -> liftIO $ BS.putStrLn "Parse error" Just commits -> liftIO $ printCommits commits 

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

अंत

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