दूसरी ओर हास्केल ट्यूटोरियल

इस लेख में मैं विशेष रूप से सामान्य और हास्केल भाषा में जटिलता और अत्यधिक विशिष्ट कार्यात्मक प्रोग्रामिंग के बारे में मिथकों को समाप्त करना चाहता हूं। मैं हास्केल की न्यूनतम समझ रखने वाले लोगों के लिए भी इस लेख को समझने का प्रयास करूंगा। लेकिन पहले, एक छोटा सा परिचय।

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

त्याग

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

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

शुरू करने से पहले

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

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

1. अपने वितरण के भंडार से हास्केल मंच को डाउनलोड और स्थापित करें;
2. EXIF के साथ काम करने के लिए हास्केल लाइब्रेरी स्थापित करें: sudo cabal install --global exif ;
3. GTK + \ Glade और हास्केल के लिए संबंधित बाइंडिंग sudo cabal install --global glade : sudo cabal install --global glade ।

समस्या का बयान

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

हम कैसे तय करेंगे

सब कुछ सरल है। आरंभ करने के लिए, आपको दो मोडों का समर्थन करने की आवश्यकता है:

• "स्वचालित" - जब स्कैन की जाने वाली निर्देशिका को कमांड लाइन के तर्क के रूप में पारित किया जाता है;
• "मैनुअल" - जब एक साधारण जीयूआई सीमा शुरू की जाती है, जिसमें हम स्वतंत्र रूप से प्रसंस्करण के लिए एक निर्देशिका का चयन करते हैं।

सामान्यतया, GUI यहाँ आवश्यक नहीं है, लेकिन मैं आपको याद दिलाता हूँ कि यह एक ऐसा छोटा प्रशिक्षण उदाहरण है जो सामान्य रूप से दिखाएगा कि Haskell में GUI कभी भी डरावना नहीं है।

इसके अलावा, कोई फर्क नहीं पड़ता कि कैटलॉग हमें कैसे फिसल गया, हम इस निर्देशिका को बायपास करते हैं (सभी उपनिर्देशिकाओं को दरकिनार करते हुए, क्योंकि कई कैमरे (यदि सभी नहीं) ध्यान से फोटो फ़ोल्डर में फोटो डालते हैं, और फिर कुछ 100PANA, 101PANA, आदि में)। .p।) और प्रत्येक व्यक्तिगत फ़ाइल को संसाधित करें।

प्रत्येक व्यक्तिगत फ़ाइल को संसाधित करना बहुत सरल है: हम Exif डेटा पढ़ते हैं और यदि कोई है, तो हम इसे (फोटो फ़ाइल) को कॉपी किए गए निर्देशिका के अनुरूप निर्देशिका में कॉपी करते हैं।

हम इसे चाहते थे या नहीं, लेकिन हमारे कार्यक्रम को क्या करना चाहिए, इस बारे में बताने की प्रक्रिया में, हमने इसके तीन मुख्य कार्यों का वर्णन किया:

• कार्यक्रम चलाना और तर्कों की जाँच करना;
• निर्देशिका ट्रैवर्सल;
• एक विशिष्ट फ़ाइल प्रसंस्करण।

अब कुछ सोर्स कोड जोड़ते हैं।

कोड के करीब

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

तो, चलिए फिर शुरू करते हैं। अर्थात्, मुख्य मॉड्यूल के मुख्य कार्य के साथ (आखिरकार, यह इसके साथ है कि कार्यक्रम शुरू होता है)। यहाँ पूरे मॉड्यूल के लिए कोड है
मुख्य:

1. मॉड्यूल मुख्य जहां
3. आयात प्रणाली (getArgs)
4. आयात प्रबंधक
5. जीयूआई आयात करें
7. मुख्य :: IO ()
8. मुख्य = getArgs >> = लॉन्च
10. - तस्वीरों के लिए एक मार्ग के साथ एक ही तर्क होना चाहिए, अन्यथा गुनी चलाएं
11. लॉन्च :: [स्ट्रिंग] -> IO ()
12. लॉन्च [एक्स] = प्रक्रियाडायरेक्टरी एक्स
13. लॉन्च _ = startGUI

* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

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

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

गीतात्मक विषयांतर। औपचारिक रूप से, सभी कार्यों को साइड इफेक्ट होने पर स्वच्छ और "गंदे" में विभाजित किया जा सकता है। मैं उँगलियों पर समझाने की कोशिश करूँगा।
एक फ़ंक्शन क्लीन है यदि यह समान आउटपुट डेटा के साथ समान आउटपुट डेटा उत्पन्न करता है, और यह कभी भी सिस्टम की किसी भी स्थिति को नहीं बदलता है और उन पर निर्भर नहीं होता है (जैसा कि यह फ़ाइल सिस्टम की स्थिति है, या एक ओपन टीसीपी कनेक्शन की उपस्थिति है)। एक उदाहरण के रूप में अतिरिक्त कार्य करें। यह दो तर्क लेता है, और यदि ये दोनों तर्क संख्या 2 के बराबर हैं, तो आउटपुट पर हम हमेशा (हमेशा हमेशा) नंबर 4 प्राप्त करेंगे। और हाँ, टीसीपी कनेक्शन जोड़ने का कार्य नहीं खुलता है।
साइड इफेक्ट्स वाले कार्य एक अलग बातचीत हैं, उन्हें केवल इनपुट / आउटपुट मोनड (IO monad) नामक एक मॉडल के माध्यम से किसी भी बाहरी अभिव्यक्तियों पर कार्यों की निर्भरता को इंगित करने के लिए आविष्कार किया गया था। धारणा की सादगी के लिए, इस समय हम केवल "इनपुट / आउटपुट" के संदर्भ में मठों के बारे में सोचेंगे (हालांकि वास्तव में यह अवधारणा बहुत व्यापक है)। साइड इफेक्ट के साथ एक फ़ंक्शन क्रियाओं के अनुक्रम का विवरण है, जिसके परिणामस्वरूप हम एक निश्चित परिणाम मूल्य प्राप्त करते हैं। एक उदाहरण:
readFile :: FilePath -> IO (String) इस फ़ाइल में दिए गए पथ पर फ़ाइल पढ़ने के लिए एक फ़ंक्शन है। अधिक सटीक रूप से, यह एक फ़ंक्शन नहीं है, यह इसका प्रकार है। फ़ंक्शन के प्रकार को पढ़ना बहुत सरल है, पहले फ़ंक्शन का नाम आता है, फिर प्रतीक के साथ दो कॉलन के बाद -> कार्यों के तर्क अलग हो जाते हैं और चरम के बाद -> वापसी मान का प्रकार होता है। यह एक आदिम वर्णन है, लेकिन यह अभी के लिए पर्याप्त है। यही है, यह देखा जा सकता है कि फ़ंक्शन एक निश्चित फ़ाइलपैथ को स्वीकार करता है और एक इनपुट / आउटपुट एक्शन देता है , जिसका निष्पादन स्ट्रिंग मूल्य देगा।
यह समझना महत्वपूर्ण है कि क्रियाओं का क्रम! = गणनाओं का क्रम। वास्तव में, हम आम तौर पर यह नहीं जानते हैं कि गणना वास्तव में किस क्रम में होगी, हम केवल उन कार्यों के क्रम को निर्धारित करते हैं जो वे पीछे हैं। इसलिए, इस तरह के अमूर्त के रूप में भिक्षुओं की उपस्थिति हास्केल को अनिवार्य नहीं बनाती है।

तो, वापस हमारे main । यह कोई तर्क नहीं लेता है और स्पष्ट रूप से एक I / O कार्रवाई करता है। इस कार्रवाई का कार्यान्वयन हमारे पूरे कार्यक्रम का निष्पादन है। यह मजाकिया है, लेकिन प्राप्त पूरे कार्यक्रम में एक भी शुद्ध कार्य नहीं लिखा गया है, जो सभी उपलब्ध ट्यूटोरियल से हड़ताली रूप से अलग है, हालांकि, यह सिर्फ समस्या है जो प्रोग्राम को हल करता है। क्रियाओं का अनुक्रम कार्यों >>= और >> द्वारा निर्धारित किया जाता है, जो दो तर्क लेते हैं। पहले मामले में, बाईं ओर कार्रवाई का परिणाम दायीं ओर फ़ंक्शन कॉल के तर्क के रूप में पारित किया जाता है, और दूसरे में, बाईं ओर की कार्रवाई को चुपचाप निष्पादित किया जाता है, जिसके बाद दाईं ओर कार्रवाई की जाती है।

इस स्थिति में, getArgs फ़ंक्शन द्वारा परिभाषित क्रिया के निष्पादन के getArgs स्ट्रिंग्स की एक सूची निष्पादित होती है, जो launch फ़ंक्शन को पास की जाती है। लॉन्च फ़ंक्शन नीचे वर्णित है। यह एक तर्क के रूप में तार की एक सूची लेता है, लेकिन यह एक I / O कार्रवाई भी देता है जो किसी भी मूल्य को वापस नहीं करता है। जैसा कि मैंने पहले ही कहा था, हास्केल में कार्यों को समीकरणों की प्रणालियों द्वारा वर्णित किया गया है, जो नेत्रहीन रूप से लॉन्च की परिभाषा में प्रस्तुत किया गया है।

गीतात्मक विषयांतर। प्रत्येक विशेष फ़ंक्शन के लिए कौन सा समीकरण चुना जाएगा यह पैटर्न मिलान प्रक्रिया, अर्थात पैटर्न मिलान से निर्धारित होता है। फ़ंक्शन टेम्पलेट को बाईं ओर परिभाषित समीकरण के भाग द्वारा परिभाषित किया गया है। पैटर्न मिलान प्रक्रिया, कोड में दिखाई देने वाले क्रम में नियंत्रणों का चयन करती है। "कुछ भी" के लिए सार्वभौमिक टेम्पलेट प्रतीक _ । टेम्पलेट्स में, आप कर सकते हैं (और चाहिए!) विभिन्न डेटा संरचनाओं का विरोध करें, उदाहरण के लिए, foo ["a",""] = 0 लिखने का अर्थ है कि यदि दो पंक्तियों "a" और "b" की सूची फ़ंक्शन फू के लिए आती है, तो यह 0 लौटेगा।

इसलिए, यदि launch फ़ंक्शन एकल मान x साथ एक सूची के साथ आता है, तो हम मानते हैं कि यह निर्देशिका का पथ है और प्रबंधक मॉड्यूल से प्रक्रिया मॉड्यूल को उस बराबर एक तर्क के साथ processDirectory है (ध्यान दें कि फ़ंक्शन किस मॉड्यूल से स्पष्ट रूप से इंगित करने की आवश्यकता नहीं है? यदि यह दोहरी व्याख्या नहीं देता है, (दो मॉड्यूल में एक ही नाम के साथ एक फ़ंक्शन है)। और अगर कुछ और (टेम्पलेट पर ध्यान दें) - तो GUI चलाएं।

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

डेटा EXIF

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

1. मॉड्यूल फोटो (
2. getTime
3. ) कहाँ
5. आयात डेटा । समय
6. आयात प्रणाली
7. आयात ग्राफिक्स
9. getTime :: स्ट्रिंग -> IO (शायद दिन )
10. getTime filePath =
11. फ़ाइल से फ़ाइलपाठ >> = (\ e -> getTag e "DateTime") >> = ( वापसी । पार्सलेट)
12. जहाँ
13. parseDateTime (Just str) = parseTime defaultTimeLocale "% Y:% m:% d% H:% M:% S" str
14. parseDateTime कुछ नहीं = कुछ भी नहीं

* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

डरावना? बिलकुल नहीं। ध्यान दें कि इस बार मॉड्यूल परिभाषा में, हमने ब्रैकेट्स में गेटटाइम फ़ंक्शन का नाम निर्दिष्ट किया है। मॉड्यूल के बाहर से सुलभ होने वाले कार्यों को यहां इंगित किया गया है। यहां C \ C ++ में फ्लैश हेडर फ़ाइलों के बजाय एक सरल और सुरुचिपूर्ण समाधान है।

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

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

• सबसे पहले, Graphics.Exif मॉड्यूल से fromFile फ़ंक्शन, Exif प्रकार का ऑब्जेक्ट पढ़ता है, इसी क्रिया को करने से हमें यह ऑब्जेक्ट मिलता है और इसे अगले फ़ंक्शन कॉल में पास किया जाता है;
• अगला फ़ंक्शन एक लैम्ब्डा एक्सप्रेशन \ e -> getTag e "DateTime" , यहाँ बैकस्लैश सूक्ष्म रूप से ग्रीक सिंबल "लैम्ब्डा" से मिलता जुलता है, यह एक तर्क का एक फ़ंक्शन है, जो पहले प्राप्त एक्सफ़ को लेता है, जो IO (शायद स्ट्रिंग) एक्शन देता है। ExT और टैग नाम को स्वीकार करते हुए getTag फ़ंक्शन;
• पिछली कार्रवाई के परिणाम को अंतिम निर्माण में स्थानांतरित किया जाता है, हम इसे और अधिक विस्तार से वर्णित करते हैं।

सबसे पहले, डरावना और विवादास्पद शब्द वापसी। वास्तव में, हास्केल पर वापस जाने से कुछ भी वापस नहीं होता है, और यह परोक्ष रूप से एक फ़ंक्शन की परिभाषा को संदर्भित करता है। वापसी एक साधारण फ़ंक्शन है जो इसे में पारित मूल्य को कार्रवाई में बदल देता है । तथ्य यह है कि एक फ़ंक्शन जिसका निष्पादन क्रियाओं की श्रृंखला का निष्पादन है, वह "शुद्ध" मान वापस नहीं कर सकता है। यह "सिर्फ स्ट्रिंग" वापस नहीं कर सकता है, क्योंकि यह स्ट्रिंग केवल कुछ निश्चित क्रियाओं को करने से ही संभव है, अर्थात, इस स्ट्रिंग को स्वयं प्राप्त करना भी एक कार्रवाई है , इसलिए हमें परिणामस्वरूप मूल्य को एक सनक में लपेटने की आवश्यकता है, अर्थात्। "इसे वापस करें" (वापसी) जहां से इसे प्राप्त किया गया था। यह मोनाड से प्राप्त किया गया था, हमें इसे फिर से मोनाड को लौटाने की आवश्यकता है। रिटर्न वैल्यू के लिए: मानदिक फ़ंक्शन इसमें परिभाषित अंतिम क्रिया देता है, अर्थात इस मामले में, बस वापस लौटें।
दूसरे, डॉट प्रतीक कार्यों की एक रचना है। आज्ञा देना fy = z; gx = y; fy = z; gx = y; तब (f . g) x == f( gx ) == z दूसरी कार्रवाई के परिणामस्वरूप, हमें शायद तारीख के साथ एक स्ट्रिंग मिलती है, और फ़ंक्शन खुद ही रिटर्न डे हो सकता है । इसलिए, हमारे पास यह स्ट्रिंग पहले पार्सिम हो सकती है, परिणामस्वरूप, जाहिर है, यह पता चला है कि कोई तारीख हो सकती है, हम इसे वापस करते हैं। वास्तव में, अंतिम क्रिया निम्नानुसार लिखी जा सकती है:

\ str -> return (parseDateTime str)

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

समय निकालने का कार्य समाप्त हो गया है। हमें निर्देशिका को बायपास करने की अनुमति है।

क्रम संख्या 2 - निर्देशिका ट्रैवर्सल

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

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

map :: (a -> b) -> [a] -> [b]

पहले तर्क में कोष्ठक पर ध्यान दें, वे रिपोर्ट करते हैं कि दूसरा तर्क स्वयं कार्य है। सामान्यतया, हास्केल में, सभी कार्य वास्तव में एक ही तर्क के कार्य होते हैं, परिणामस्वरूप, उनमें से कुछ मानों को वापस नहीं करते हैं, लेकिन वे कार्य होते हैं। अतिरिक्त कार्य पर विचार करें:

add :: Int -> Int -> Int

इसका प्रकार इस तरह सही लिखा जाना चाहिए:

add :: (Int -> (Int -> Int))

फर्क महसूस करते हैं? तो, add 5 2 मान लौटाएगा 7. लेकिन add 5 , एक फ़ंक्शन लौटाएगा जो प्रकार Int का मान लेता है और प्रकार Int का मान लौटाता है! यह ऐसे चमत्कारों पर है कि मानचित्र फ़ंक्शन का उपयोग करने का सिद्धांत बनाया गया है। इस प्रकार हम मूल सूची के सभी तत्वों में एक जोड़ते हैं:

map (+ 1) [1,2,3]

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

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

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

1. - तत्व का प्रसंस्करण: यदि कैटलॉग - पुनरावृत्ति दर्ज करें, अन्यथा हम फोटो को संसाधित करते हैं
2. processSingle :: ( स्ट्रिंग , बूल) -> IO ()
3. processSingle (पथ, सही) = processDirectory पथ
4. processSingle (पथ, गलत) = करते हैं
5. चित्र डायर <- getPicturesDir
6. शायदDate <- getTime पाथ
7. copyPhoto चित्र
8. जहाँ
9. - सुरक्षित नकल
10. कॉपी फोटो कुछ भी नहीं = वापसी ()
11. copyPhoto चित्र (बस तिथि) = करते हैं
12. let newPath = Pictures ++ "/" ++ (formatTime defaultTimeLocale "% Y /% B /% d" दिनांक)
13. copyFile पथ newPath

* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

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

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

1. फोब्बर = एक्शन १ >> = एक्शन २ >> = एक्शन ३
3. फोबार '= करते हैं
4. परिणाम 1 <- कार्रवाई 1
5. परिणाम 2 <- क्रिया 2 परिणाम 1
6. क्रिया ३ परिणाम २

* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

इस मामले में, दो अलग-अलग क्रियाओं के सिर्फ दो परिणाम तीसरे फ़ंक्शन के तर्क के रूप में उपयोग किए जाते हैं। प्रतिलिपि फ़ंक्शन तुच्छ है: फिर से टेम्पलेट से मेल खाते हुए, यदि आपको तारीख मिलती है, तो फ़ाइल को path से newPath पर newPath । हम दो विशेषताएं नोट करते हैं:

• पथ "शीर्ष" प्रक्रिया का एक तर्क है फ़ंक्शन, अर्थात्। copyPhoto एक संदर्भ-संवेदनशील फ़ंक्शन है;
• चलो भाषा का एक कीवर्ड है, यह आपको एक निश्चित मूल्य को एक निश्चित नाम से बांधने की अनुमति देता है (कृपया ध्यान दें कि यह एक असाइनमेंट नहीं है , इसका मान परिवर्तित नहीं किया जा सकता है, हालांकि यह नाम एक अलग मूल्य के लिए बाध्य हो सकता है, लेकिन अगर आपने इसे किसी फ़ंक्शन से पहले पारित किया है , तो यह वहां नहीं बदलेगा) - इस मामले में, यह बस सुविधा के लिए लागू किया जाता है।

formatTime स्पष्ट रूप से एक फ़ंक्शन है जो एक स्थान, पैटर्न और दिनांक लेता है, और उस पैटर्न के लिए स्वरूपित दिनांक के साथ एक स्ट्रिंग देता है।
++ एक सूची सम्मेलन समारोह है।

केवल, हमने केवल फ़ंक्शन # 3 का वर्णन किया है। क्या यह वास्तव में सरल है? तो हमारा फंक्शन नंबर 2 कैसा दिखेगा। यह इस तरह दिखेगा:

1. प्रक्रियाडायरेक्टरी :: स्ट्रिंग -> आईओ ()
2. processDirectory dir =
3. getDirectoryContents dir >> = checkItems >> = (mapM_ processSingle)
4. जहाँ
5. - निर्देशिका सामग्री की दी गई सूची के लिए, प्रत्येक तत्व के लिए एक मार्कर "निर्देशिका" के साथ ट्यूपल लौटें
6. checkItems xs = mapM सिंगलचेक xs
7. जहाँ
8. सिंगलचेक पाथ = करो
9. isDirectory <- (doDirectoryExist path)
10. वापसी (पथ, isDirectory)

* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

इस पर करीब से नज़र डालें, वास्तव में यह एक बहुत ही सरल कार्य है। लेकिन पहले, mapM और mapM_ के बारे में कुछ शब्द।

गीतात्मक विषयांतर। map, , . , map. :

mapM :: (a -> IO b) -> [a] -> IO [b]
mapM_ :: (a -> IO b) -> [a] -> IO ()


, map, , , . , . , .

, :

• singleCheck — , , , - ( , !);
• checkItems ( ) , - ( , mapM);
• , processDirectory , processSingle ( , , , ).

! अंत! . , GUI.

GUI

? , . — SQL. . , ( ) , , , .

Haskell — , , , ! . Haskell GTK. : Glade, Haskell .

:

1. prepareGUI mainWindow startButton fileChooser =
2. करना
3. onDestroy mainWindow mainQuit
4. onClicked startButton (processClick fileChooser)
5. where
6. processClick fileChooser = fileChooserGetFilename fileChooser >>= processDirectory

* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

, .

निष्कर्ष

github ( ), , . , , , Haskell, . , , - . : , MVC - Haskell! , — , , !.. , - .

github
Haskell