असली दुनिया में हास्केल

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

डेटा विवरण

मैं टेलीकॉम में काम करता हूं: फिक्स्ड टेलीफोन, इंटरनेट, आईपी-टेलीफोनी। कार्यों में पीबीएक्स से आईपी-टेलीफोनी सर्वरों से ट्रैफ़िक को संसाधित करना, वर्तमान बिलिंग का समर्थन करना, सॉफ्टवेयर लिखना और नेटवर्क, डोमेन (हाँ, "सभी ट्रेडों का जैक") शामिल हैं। हाल ही में, मेरे संगठन में नए उपकरण लगाए गए जो पूरी तरह से अलग सिद्धांतों पर काम करते थे, और यातायात, तदनुसार, भी बदल गया। अब यह दो संस्करणों में आता है: पुराने स्टेशनों से और नए से। नए ट्रैफ़िक को द्विआधारी और पाठ प्रारूपों में दोहराया गया है। बायनेरिज़ हमें बिल्कुल भी शोभा नहीं देता (हालाँकि कुछ अनजाने में कहा गया: "वहाँ क्यों? आप उन्हें ले जाइए, और वे खुद बिलिंग में लग जाते हैं!"), पाठ एक जगह अधिक परिमाण का क्रम लेता है, लेकिन इसके साथ कुछ करना संभव है। पुराने उपकरणों से यातायात अभी भी चल रहा है, और हम इसे स्थानीय DBMS की सेवाओं का उपयोग करके अच्छी तरह से स्थापित योजनाओं का उपयोग करके एक साथी के साथ फेंक रहे हैं। नए स्टेशनों से यातायात के लिए समान सेवाओं को कॉन्फ़िगर करना संभव होगा, लेकिन कई सुविधाओं की खोज की गई थी। नए स्टेशनों पर ट्रैफ़िक हर 15 मिनट में अलग-अलग फ़ाइलों को लिखा जाता है; कुल मिलाकर, प्रति माह लगभग 3,000 ऐसी फाइलें प्राप्त होती हैं (आदर्श रूप से - 31 दिनों के लिए 2976 और 30 दिनों के लिए 2880)। पागलपन के लिए आप प्रत्येक फ़ाइल को अलग से आयात नहीं करेंगे। यह संभव है और यहां तक ​​कि उन्हें एक में मिलाने के लिए आवश्यक है, क्योंकि वे सभी पाठ हैं, और कॉल रिकॉर्ड लाइन द्वारा व्यवस्थित किए जाते हैं। मैनुअल मर्जिंग इस तरह दिखता है: आप पिछले महीने ही फाइलों का चयन करते हैं और उन्हें कमांड लाइन पर सबसे सरल मर्ज स्क्रिप्ट में जोड़ते हैं। फ़ाइल नाम प्रारूप तय हो गया है, इसलिए, विलय को स्वचालित किया जा सकता है, केवल आपको वर्ष और महीने को पार्स करना होगा। लिनक्स सस्ते और खुशमिजाज किस्म के बैश , पर्ल या पाइथन का उपयोग करता है , लेकिन आपने उन्हें एक ऑपरेशन के लिए विंडोज मशीन पर स्थापित नहीं किया है, वही पावरशेल के लिए जाता है। और cmd एक विकृति है, जिसके बारे में हम अच्छी तरह से जानते हैं। ;) अंत में, ट्रैफ़िक में भी आश्चर्य का पता चला, जिसकी वजह से DBMS टूल्स का उपयोग करके विलय और आयात करने के बाद भी, बहुत सारे SQL कार्य की आवश्यकता थी। सामान्य तौर पर, कुछ कारक हस्केल के लिए एक कार्य के रूप में सफलतापूर्वक विकसित हुए, जिसका मैंने उस समय (अप्रैल-मई 2011) अध्ययन करना शुरू किया।

तो, प्रति माह ~ 3,000 15 मिनट की फाइलें। उपकरण पर, आप अंतराल को बदल सकते हैं और 15 मिनट नहीं, बल्कि किसी अन्य मूल्य पर सेट कर सकते हैं: 5, 10, 30, 45 ... क्रमशः फ़ाइलों और उनके आकारों की संख्या, बदल जाएगी। उदाहरण फ़ाइल का नाम (05/09/2011 09:30:00):

  999992011050909300081.txt
 99999 - पहचानकर्ता उपकरण में सिलना (स्पष्ट कारणों के लिए, मैंने इसे नौ के साथ बदल दिया)
      2011 - वर्ष
          05 - महीना
            09 - दिन
              09 - घंटे
                30 मिनट
                  00 - सेकंड
                    81 - कुछ यादृच्छिक संख्या, शायद एक सेकंड के दसवें। 

अधिक ग्राहक हैं, और प्रत्येक फ़ाइल आकार में लगातार बढ़ रही है। अब हमारे पास प्रति फ़ाइल औसतन २४० लाइनें हैं, लेकिन एक मौसमी गर्मी की स्थिति थी, लोग छुट्टी पर गए और कम बुलाया। सितंबर के लिए, हम डेढ़ से दो बार गतिविधि में वृद्धि की उम्मीद करते हैं।

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

  | R210 | 2011-06-24 21: 43: 53 | 2011-06-24 01: 43: 52 | 1 | 

जैसा कि आप देख सकते हैं, केवल 4 फ़ील्ड हैं: रिकॉर्ड प्रकार पहचानकर्ता, प्रारंभ दिनांक, अंतिम तिथि (आईएसओ 8601 / एसक्यूएल प्रारूप) और, किसी कारण के लिए, एक। खेतों को एक ऊर्ध्वाधर बार द्वारा अलग किया जाता है, जो रिकॉर्ड की शुरुआत में और अंत में होना चाहिए, ताकि वास्तव में 1 और क्षेत्र हों, अर्थात्, 5. यह मान लेना सुविधाजनक है कि सूचकांक 0 वाला क्षेत्र खाली है, पहले ऊर्ध्वाधर पट्टी से पहले स्थित है। फिर महत्वपूर्ण क्षेत्रों की उलटी गिनती 1 से जाएगी।

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

  | R200 | 99999 | 111111 | CR, CS, AM | 1 | 3022 | 2222 | 333333 ||| 2011-06-23 11: 33: 58 | C | 2011-06-23 11: 34: 22 | S | ० | १६ | १ |||||| १ || १ || १६२ || १ 1६ | १ | | १ | १२ | १४ | २४ |||||||| १६ | ० ||| || 192.168.1.172 || 192.168.1.12 |||||| 8 | 8 | 20 | 20 | 64 | 64 | 20 | 0 | 0 | OS | 7777 | 8888 | 555555 | 666666 | 0 | 8 | 9 | ||| OS || १ ९ ||| ३० | १० | ४२ | ४३ ||||||||||| १ || १ || २ | ३ || २२२२२ |||| || २ | १ || ३३३३३३ |||||||||| 

हम सूचकांक [7, 8, 9, 12, 14, 36, 112, 122] के साथ रुचि रखते हैं, और अंत में हम उन सभी चीजों को फ़िल्टर करना चाहेंगे जो अनावश्यक हैं ताकि हम DBMS में बहुत अधिक आयात न करें। केवल कच्चे डेटा से क्या आवश्यक है, यह चुनना, हमें लाइन मिलती है:

  रिकॉर्ड: 3022 | 222222 | 333333 | 2011-06-23 11: 33: 58 | 2011-06-23 11: 34: 22 | 24 | 222222 | 333333 |
 सूचकांक: 7 | 8 | 9 | 12 | 14 | 36 | 112 | 122 |

 संकेत |  व्याख्या
 ---------------------------
 7 |  चिता का क्षेत्र कोड
 8, 112 |  आउटगोइंग नंबर
 9, 122 |  आने वाली संख्या
 12 |  बातचीत की शुरुआत की तारीख और समय
 14 |  समाप्ति तिथि और समय
 36 |  सेकंड में बात की अवधि 

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

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

  | 7 | 8 | 9 | 12 | 14 | 36 |
 | 3022 | 222222 | 333333 | 2011-05-23 13: 07: 54 | 2011-05-23 13: 37: 54 | 1800 |
 | 3022 | 222222 | 333333 | 2011-05-23 13: 07: 54 | 2011-05-23 13: 59: 40: 3106 |

 | 3022 | 444444 | 555555 | 2011-05-23 14: 53: 52 | 2011-05-23 15: 23: 52 | 1800 |
 | 3022 | 444444 | 555555 | 2011-05-23 14: 53: 52 | 2011-05-23 15: 53: 52: 3600 |
 | 3022 | 444444 | 555555 | 2011-05-23 14: 53: 52 | 2011-05-23 16: 00: 50: - 4018

 | 3022 | 666666 | 777777 | 2011-05-23 19: 15: 55 | 2011-05-23 19, 45: 54: 1800 |
 | 3022 | 666666 | 777777 | 2011-05-23 19: 15: 55 | 2011-05-23 20: 15: 15: 54 | 3600 |
 | 3022 | 666666 | 777777 | 2011-05-23 19: 15: 55 | 2011-05-23 20: 45: 54 | 5400 |
 | 3022 | 666666 | 777777 | 2011-05-23 19: 15: 55 | 2011-05-23 20: 47: 17 | 5483 | 

अब आप देख सकते हैं कि नमक क्या है, और फिर अतिरिक्त क्षेत्रों, अक्षरों और संख्याओं के एक समूह के बीच, हजारों समान लोगों के बीच इन रिकॉर्डों को खोजना मेरे लिए आसान नहीं था। सामान्य तौर पर, यह या तो भाग्य, या अंतर्ज्ञान, या जादू था। :) और उत्तर सरल है: हर आधे घंटे (1800 सेकंड) पर उपकरण कुछ ऐसा होने की स्थिति में "बातचीत में मील का पत्थर" चिह्नित करता है। यहां तक ​​कि अगर बातचीत के आखिरी 29 मिनट किसी तरह खो गए थे, तो पूरे पिछले तीन घंटे के प्रवचन को कई बार दर्ज किया गया था - अधिक विश्वसनीयता के लिए। पिछले रिकॉर्ड में वास्तविक डेटा होगा। शायद, उपकरण पर, मील के पत्थर की अवधि को किसी भी तरह से बदला जा सकता है, लेकिन अब तक उनकी संख्या इस तरह दिखती है: [1800, 3600, 5400, 7200, 9000, 9000 से अधिक ..] यह भी उल्लेखनीय है कि मील का पत्थर कई "महत्वहीन" लोगों में भिन्न होता है परिणाम रिकॉर्ड से फ़ील्ड। शायद यह भविष्य में इस पर विचार करने के लायक है ताकि अनावश्यक को बेहतर तरीके से फ़िल्टर किया जा सके, लेकिन अब मैंने इस श्रृंखला से अवधि के साथ सभी रिकॉर्डों को छोड़ने का फैसला किया है। सैद्धांतिक रूप से, यहां सामान्य कॉल के कुछ छोटे प्रतिशत खो जाएंगे, लेकिन इसके लिए यह आवश्यक है कि कोई व्यक्ति आधे घंटे के लिए दूसरी बात करे। इस की संभावना बहुत, बहुत छोटी है, और हमारे वॉल्यूम इतने महत्वपूर्ण नहीं हैं कि बड़ी संख्या का कानून किसी भी तरह से नमूने को प्रभावित करता है। हमने इस घटना को रचनात्मक रूप से बुलाया: "1800 सेकंड की समस्या।"

संक्षेप में कार्यक्रमों के बारे में

कुल मिलाकर, मैंने चार प्रोग्राम बनाए जो आवश्यक फाइलों को मर्ज कर उपयोगी जानकारी को फ़िल्टर करता है। प्रारंभ में, वे पार्सर और विलय थे - दो कार्यक्रमों को अलग से लिखा गया और एक तीसरे में मिलाया गया, जिसे विलय भी कहा जाता है। उन सभी ने बहुत धीरे-धीरे काम किया और बहुत सारी मेमोरी का उपभोग किया, हालांकि वे कार्यों से मुकाबला करते थे। वे 500 एमबी मेमोरी (या इससे भी अधिक, क्योंकि स्वैप काम किया है) के साथ कम से कम 10 मिनट के लिए एक महीने के डेटा (240 लाइनों = 720000 लाइनों की 3000 फाइलें) को संसाधित कर सकते हैं। बहुत, बहुत डरावना परिणाम। और हालांकि यह काम महीने में एक बार करना पड़ता था, लेकिन मेरे साथी ने हास्केल पर चिल्लाया । सच है, हास्केल का इससे कोई लेना-देना नहीं है; मैंने इसे एक नौसिखिया फंक्शनलिस्ट की कई विशिष्ट गलतियों के कार्यक्रमों में बनाया, जिसकी वजह से कुटिल एल्गोरिदम ने बहुत बुरा काम किया। लेकिन उन्होंने काम किया! इससे भी अधिक: प्रोग्राम (और उनमें से सबसे बड़ी केवल 150 उपयोगी लाइनें लेता है) कमांड लाइन से कॉन्फ़िगर किया जा सकता है। यहां वे विशेषताएं हैं जो उपलब्ध थीं:

1. मापदंडों के बिना मोड में काम करें। फ़ील्ड डिफ़ॉल्ट रूप से ली जाती हैं, पिछले महीने की फाइलें ली जाती हैं।
2. मापदंडों के साथ एक मोड में काम करें:
- फ़ील्ड्स [क्षेत्र सूचकांकों की सूची>] - जो क्षेत्र लेने के लिए (पार्सर फील्ड्स [1, 24, 55]);
- (yyyy, mm) - किस महीने से प्रक्रिया (विलय (2011, 5));
-W - बाहर काम करने के बाद कंसोल विंडो को बंद न करें ("प्रतीक्षा" शब्द से)।
3. परिणाम तीन फाइलें थीं:
- yyyy.mm.txt - इस महीने के लिए कच्चे ट्रैफ़िक वाली सभी फाइलें इसमें विलीन हो गईं;
- संसाधित। txt - केवल इस महीने के लिए आवश्यक फ़ील्ड के साथ फ़ाइल करें;
- yyyy.mm.txt.log - एक लॉग फ़ाइल जहां कच्ची कच्ची फाइलें सूचीबद्ध हैं और सारांश जानकारी लिखी गई है (लाइनों की संख्या, फाइलें, तिथि सीमा)।
4. कार्यक्रम संसाधित ट्रैफ़िक के आंकड़े और उदाहरण प्रदर्शित करते हैं।

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

पहला कार्यक्रम

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

रिप्लेसचर्स :: चार -> चार -> चार -> चार
प्रतिस्थापन सीएचसी के साथ सी = अगर सी == क्या सी तो सी के साथ सी

interestFields :: [ स्ट्रिंग ] -> [ इंट ] -> [ स्ट्रिंग ]
interestFields s takeWhat = अपरिभाषित - स्टब

isR200 :: [ स्ट्रिंग ] -> बूल
isR200 s = ( हेड s ) == "R200"

processLine :: स्ट्रिंग -> स्ट्रिंग
processLine s = यदि isR200 sInWords तो unwords ( interestFields sInWords [ 1 , 2 , 3 ] ) और [ ] - [1,2,3] - परीक्षण क्षेत्र
जहाँ sInWords = शब्द ( मानचित्र ( प्रतिस्थापन) | '' ' ) s )

processString :: स्ट्रिंग -> [ स्ट्रिंग ]
processString s = मानचित्र processLine ( लाइनें $ s )

मुख्य :: IO ( )
मुख्य = करते हैं
str <- readFile "merged.txt"
PutStrLn ( " \ r \ n " इंटरलेक्ट करें ( $ स्ट्रिंग को संसाधित करें ) )

आप तुरंत प्रकार चार -> चार -> चार -> चार प्रकार के साथ अजीब फ़ंक्शन रिप्लेसमेंट नोटिस कर सकते हैं। विचार यह था: एक लाइन-रिकॉर्ड लें, वर्टिकल बार की जगह लें '|' अंतरिक्ष द्वारा और शब्दों को स्ट्रिंग में विभाजित करने के लिए शब्द फ़ंक्शन का उपयोग करें:

sInWords = शब्द ( नक्शा ( प्रतिस्थापन) | '' ' ) s )

SInWords को निष्पादित करने के परिणामस्वरूप, हमें निम्नलिखित रूपांतरण प्राप्त होते हैं:

"। R200 | 99999 | 111111 | सीआर, सीएस, एएम | 1 | 3022 | 222222 | 333333.pg 2011-06-23 11: 33: 58 |" ->
"R200 99999 111111 CR, CS, AM 1 1 3022 222222 333333 2011-06-23 11:33:58" ->
[ "R200" , "99999" , "111111" , "CR, CS, AM" , "1" , "1" , "3022" , "222222" , "333333" , "2011-06-23" , " 11:33:58 " ]

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

प्रतिस्थापन '' -> '*';
की जगह '|' -> '';
शब्द समारोह द्वारा शब्द को तोड़ना;
फ़ील्ड की एक सूची संसाधित करना, इच्छित सूचकांक के साथ फ़ील्ड प्राप्त करना;
Unwords फ़ंक्शन के साथ फ़ील्ड मर्ज करें;
प्रतिस्थापन '' -> ''
रिप्लेसमेंट '*' -> ''

इसके अलावा, इन भयानक परिवर्तनों के बाद, प्राप्त फ़ील्ड की संख्या स्रोत फ़ील्ड की संख्या के साथ मेल नहीं खाती, क्योंकि खाली फ़ील्ड अंततः पूरी तरह से गायब हो गए (ऊपर रूपांतरण उदाहरण देखें)। यह अच्छा है कि सभी रिकॉर्ड में खाली / भरे हुए खेत एक ही स्थान पर थे, अन्यथा मुझे अप्रिय कलाकृतियाँ मिल जातीं। कोड, जैसा कि आप देख सकते हैं, न केवल निरर्थक है, बल्कि बदसूरत भी है। मैं इसकी अस्मिता संबंधी जटिलता का मूल्यांकन करने के लिए भी अनुमान नहीं लगाता; मुझे लगता है कि वह O (n ^ 2) से बहुत आगे थी। इसके अलावा, 12 संशोधन के करीब, मुझे एहसास हुआ कि हमें उन क्षेत्रों के साथ कुछ करने की ज़रूरत है जो दोहरे ऊर्ध्वाधर सलाखों के कारण खो गए हैं। और एक और रूपांतरण जोड़ा:

- ताकि "" "के रूप में चिह्नित खाली फ़ील्ड सही ढंग से संसाधित हो जाएं, उनके बीच एक स्थान डाला जाता है।
refieldDoubles :: स्ट्रिंग -> स्ट्रिंग
refieldDoubles [ ] = [ ]
RefieldDoubles ( ' | ': [ ]] = "|
RefieldDoubles ( ' | ': ' | ': ss ) = "| | | ++ ( रिफिल डबल्स ( ' | ': ss ) )
refieldDoubles ( s: [ ]] = [ s ]
refieldDoubles ( s: ss ) = s: ( refieldDoubles ss )

इस प्रकार प्रत्येक पंक्ति में एक और पूर्ण मार्ग जोड़ा गया! खैर, सच में - बंदर श्रम। लेकिन आपको काफी कुछ करना था: इसके बजाय Data.String.Utils मॉड्यूल से विभाजन फ़ंक्शन का उपयोग करें या अपना स्वयं का संस्करण लिखें। फिर, रिकॉर्ड लाइन के साथ सिर्फ एक पास में, मुझे सही फ़ील्ड ब्रेकडाउन मिलेगा:

विभाजित "|" "। R200 | 99999 | 111111 | सीआर, सीएस, एएम | 1 | 3022 | 222222 | 333333.pg 2011-06-23 11: 33: 58 |" ->
[ "" , "R200" , "99999" , "111111" , "CR, CS, AM" , "1" , "1" , "3022" , "222222" , "333333" , "" , "" "2011-06-23 11:33:58" , "" ]

मैं क्या कह सकता हूं ... फेसपालम कोई शब्द नहीं, केवल भावनाएं।

क्या सुधार संभव हैं

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

रिप्लेसमेंट्स s = map ( रिप्लेसचेयर ’ | ’ ’’ ) ( मैप्स ( रिप्लेसकर ’’ ’ * ’ ’s )
- ->
रिप्लेसमबल्स = नक्शा ( रिप्लेसचेयर ’ | ’ ’’ । रिप्लेसकर ’’ ’’ ’’ )


isR200 s = ( हेड s ) == "R200"
- ->
isR200 ( "R200" : _ ) = सत्य
isR200 _ = गलत


प्रतिस्थापन सीएचसी के साथ सी = अगर सी == क्या सी तो सी के साथ सी
- ->
बदलो व्हाट्सएप withC c | c == whatC = withC
| अन्यथा = सी


processLine s = यदि isR200 sInScript तब unwords ( interestFields sInbooks [ 1 , 2 , 3 ] और ] [ ]
जहाँ sInWords = शब्द ( मानचित्र ( प्रतिस्थापन) | '' ' ) s )
- ->
processLine s | isR200 sInatalog = unwords ( interestFields sInWords [ 1 , 2 , 3 ] )
| अन्यथा = [ ]
जहाँ sInWords = शब्द । नक्शा ( बदलें ' | ' '' ' ) $ s


processString s = मानचित्र processLine ( लाइनें $ s )
- ->
processString = map processLine । पंक्तियां

इंटरकलेट फ़ंक्शन "\ r \ n" को आम तौर पर अनलाइन के साथ बदलने की आवश्यकता होती है । यह छोटा और स्पष्ट होगा, और परीक्षण में अनलिस्ट्स ने शानदार प्रदर्शन दिखाया - कम से कम 30%:

  ItemCnt testUnlines (ns) testIntercalate (ns) प्रतिशत
 10 23.84 34.05 29.9
 100 22.70 34.62 34.4
 1000 23.28 35.48 34.3
 10000 22.17 35.48 37.5
 50,000 22.13 33.26 33.4
 100000 21.06 35.47 40.6
 200000 22.70 34.05 33.3 

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

- पुराना कोड:
- तर्क 1 - कच्चे भोजन की सूची
- तर्क 2 - आवश्यक अनुक्रमित सूची
टेकइंटरेस्ट :: [ स्ट्रिंग ] -> [ इंट ] -> [ स्ट्रिंग ]
takeInterest _ [ ] = [ ]
takeInterest ss ( n: ns ) = [ ss !! n ] ++ takeInterest ss ns

- नया कोड:
- तर्क 1 - बैटरी
- तर्क 2 - आवश्यक अनुक्रमित सूची
- तर्क 3 - कच्चे खेतों की सूची
collectFields :: Int -> [ Int ] -> [ String ] -> [ String ]
collectFields _ _ [ ] = [ ]
collectFields idx fis ( s: ss ) | idx ` elem` fis = s: collectFields ( idx + 1 ) fis ss
collectFields idx fis ( s: ss ) | अन्यथा = collectFields ( idx + 1 ) fis ss

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

  ItemCnt takeInterest (ns) collectFields (ns) Percent
 10 17.33 36.84 52.9
 100 20.58 36.84 44.1
 1000 21.67 37.92 42.8
 10000 21.13 36.84 42.6
 50,000 21.67 37.92 42.8 

आगे बढ़ते हैं

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

मुख्य :: IO ( )
मुख्य = करते हैं
args <- getArgs
curDir <- getCurrentDirectory
dirContents <- getDirectoryContents curDir
curTime <- टी। getClockTime
monthAgoTime <- $ T लौटाएं । addToClockTime ( T. TimeDiff 0 ( 1 ) 0 0 0 0 0 0 ) curTime
CalendarMonthAgoTime <- T. कैलेन्डरटाइम माहअगो टाइम
Let शायदDateRange = केस आर्गन्स
( a: b: _ ) -> readDateRange ( unwords [ a , b ] )
_ -> केवल $ defaultDateRange CalendarMonthAgoTime
मामला हो सकता है
बस डॉ -> करना
आज्ञा देना fsToMerge = filesToMerge dirContents डॉ
let fsToMergeCountStr = $ लम्बाई fsToMerge दिखाएं
लेट मर्जलोग = ( newFileName dr ++ ".log" )
let dateRangeMsg = "DateRange:" ++ शो डॉ
fsContents <- fsToMerge को मर्ज करें
राइटफाइल ( newFileName dr ) ( अनलॉग्स fsContents )
writeFile mergeLog ( unlines fsToMerge ++ printf " \n %s \n Total files: %s" dateRangeMsg fsToMergeCountStr )
putStrLn ( unlines fsContents )
putStrLn dateRangeMsg
--putStrLn ("Files to merge: " ++ unlines fsToMerge)
putStrLn ( printf "Count of files: %s. See %s for file list." fsToMergeCountStr mergeLog )
Nothing -> putStrLn ( "Invalid date range." )

यह कोड क्या करता है, मैं इसमें जाने की सलाह भी नहीं देता ... लेकिन यह यहाँ था कि भविष्य की एक बड़ी त्रुटि का रोगाणु समाप्त हो गया, जिसके कारण पुराने कार्यक्रम के नवीनतम संस्करण ने भारी मात्रा में मेमोरी को बर्बाद कर दिया। मर्ज फ़ंक्शन पर विचार करें , जिसे इस कोड से कहा जाता है:

मर्ज :: [ स्ट्रिंग ] -> IO [ स्ट्रिंग ]
मर्ज fsToMerge = mapM readFile fsToMerge

यह नियंत्रित की जाने वाली फ़ाइलों की सूची लेता है, उन्हें पढ़ता है, और उनकी सामग्री की सूची लौटाता है। कोड में दो लाइनें हैं:

करना
...
fsContents <- मर्ज fsToMerge
WriteFile ( newfilename डॉ ) ( unlines fsContents )
...

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

करना
...
fsContents <- readFilesToMerge fsToMerge
देना mergedContents = unlines fsContents
WriteFile ( newfilename डॉ ) mergedContents
जाने processedContentStr = unlines $ processData nedeedFields mergedContents
...

और यह सिर्फ फेसप्लम खराब नहीं है, यह डेटाफ्लो कॉन्सेप्ट का घोर उल्लंघन है। यह इस तरह होना चाहिए:

 स्कीम 1
       _____ _____ _____ 
       |  |  |  |  |  |
ए 1 -> | एफ (ए 1) | -> बी 1 -> | जी (बी 1) | -> C1 -> | H (C1) | -> परिणाम 1 -> बचाओ
      | _____ | | _____ | | _____ |

       _____ _____ _____
       |  |  |  |  |  |
ए 2 -> | एफ (ए 2) | -> बी 2 -> | जी (बी 2) | -> C2 -> | H (C2) | -> परिणाम 2 -> बचाओ
      | _____ | | _____ | | _____ |

       _____ _____ _____ 
       |  |  |  |  |  |
A3 -> | F (A3) | -> बी 3 -> | जी (बी 3) | -> C3 -> | H (C3) | -> परिणाम 3 -> बचाओ
      | _____ | | _____ | | _____ |


...-> ... -> ... -> ... -> ... - ... -> परिणाम n -> बचाओ 

और यह इस तरह निकला:

 योजना २
    ____________________ ____________________ ____________________
    |  |  |  |  |  |
    |  |  |  |  |  |
    |  |  |  |  |  |
उ०—> | एफ (ए) | -> बी-> | जी (बी) | -> C-> | एच (सी) | -> परिणाम-> बचाओ
    |  |  |  |  |  |
    |  |  |  |  |  |
   | ____________________ | | ____________________ | | ____________________ |

मैंने तुरंत भागों के अनुक्रमिक प्रसंस्करण और पूर्ण रूप से सब कुछ के प्रसंस्करण के बीच अंतर महसूस किया। अब मुझे पता है: यह एक ही बार में पूरी मात्रा में काम करने के लायक नहीं है, यह एक तंत्र बनाना बेहतर है जो बैचों में डेटा जारी करता है - यह स्मृति में प्रभावी और तेज दोनों होगा। और, सब कुछ के अलावा, दूसरी योजना के अनुसार बनाया गया एक कार्यक्रम समानांतर नहीं किया जा सकता है। एक शब्द में डरावना, ...

बाद में, मैंने पुराने कार्यक्रम को अनुकूलित करने की कोशिश की, - लगभग हर जगह स्ट्रिंग को बाइटस्ट्रिंग के साथ बदल दिया । लाभ, निश्चित रूप से, छोटा था, लेकिन - आप कोहरे के प्रशंसक को तितर-बितर नहीं कर सकते।

कहने की जरूरत नहीं है, मैंने नया कार्यक्रम, NgnTraffic, पहले से ही ज्ञान की सामान्य आपूर्ति कर रहा था? इसमें बहुत कुछ देखा गया है। कार्यक्रम को मॉड्यूल में विभाजित किया गया है: मुख्य , निरंतर ,DataProcess , FileListProces , Options , Tools , Types । बेशक , स्कीम 1 का उपयोग किया जाता है। स्ट्रिंग के बजाय , बाइटस्ट्रिंग प्रकार (सख्त संस्करण) को मूल रूप से लिया गया था । कोड अधिक कंघी है, यहां तक ​​कि हाथ पर एक बिटलेस शैली भी। और, सबसे महत्वपूर्ण बात, कार्रवाई का सिद्धांत बदल गया है। सबसे पहले, संसाधित होने वाली फ़ाइलों की एक सूची एकत्र की जाती है - यह हिस्सा पुराने प्रोग्राम से समान के समान है। फिर, हालाँकि, फ़ाइलों को एक बार में एक बड़े चर में पढ़ा नहीं जाता है, लेकिन प्रत्येक को अलग से पढ़ा जाता है। इसकी सामग्री को तुरंत संसाधित किया जाता है, लाइनों को पार्स किया जाता है, रिकॉर्ड फ़िल्टर किए जाते हैं, आवश्यक फ़ील्ड को बाहर निकाला जाता है। परिणामी फ़ाइल में परिणाम जोड़ा जाता है। नतीजतन, हमारे पास चक्र है "डिस्क से पढ़ें ( एफ (एन))) - स्ट्रिंग प्रसंस्करण ( G (Bn) ) - डिस्क ( H (Cn) ) को परिणाम लिख रहा है - और कई बार फाइलों की संख्या में। साथ ही, बेशक, एक वर्ण के दूसरे के लिए कोई प्रतिस्थापन नहीं है, लेकिन Data.ByteString.Char8 मॉड्यूल से एक सरल विभाजन फ़ंक्शन है , जो एक पास में फ़ील्ड में रिकॉर्ड स्ट्रिंग को विभाजित करता है और अपने आप में प्रदर्शन का एक राक्षसी हिस्सा जीतता है। यहां योजना 1 को संतुष्ट करने वाले कार्य हैं:

process' :: ResFilePath -> FieldIndexes -> FilePath -> IO ( )
process' resFile fis targetFile = do
fileContents <- C . readFile targetFile
let processResult = processData fis predicates fileContents
C . appendFile resFile processResult

process :: ResFilePath -> [ FilePath ] -> FieldIndexes -> IO String
process _ [ ] _ = return "No files to process."
process resFile fs fieldIndexes = do
C . writeFile resFile C . empty
mapM_ ( process' resFile fieldIndexes ) fs
return "All ok."

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

डेटा विधेय = NotInList [ सी । बाइटस्ट्रिंग ]
|InList [ सी । ByteString ]
टाइप करें PredicateMap = [ ( FieldIndex , Predicate ) ]

और ये दिए गए निरंतर विधेय हैं:

predicates :: PredicateMap
predicates = [ ( 1 , InList [ C . pack "R200" ] ) ,
( 36 , NotInList ( map C . pack [ "1800" , "3600" , "5400" , "7200" , "9000" , "10800" , "12600" , "14400" , "16200" , "18000" , "19800" , "21600" , "23400" ] ) ) ]

यह अनुमान लगाना आसान है कि केवल वे अभिलेख जिनके लिए फ़ील्ड 1 "R200" के बराबर है और फ़ील्ड 36 "समस्या 1800 सेकंड" की सूची में नहीं है, वे विधेय को संतुष्ट करेंगे। स्क्रीनिंग चेकप्रेडेट और जांचफिल्ड फ़ंक्शन में होती है :

checkPredicate :: Predicate -> C . ByteString -> Bool
checkPredicate ( NotInList l ) str = ( not . elem str ) l
checkPredicate ( InList l ) str = elem str l

examineFields :: Int -> PredicateMap -> Fields -> Bool
examineFields _ _ [ ] = True
examineFields idx preds ( s:ss ) = case L . lookup idx preds of
Just pred -> ( checkPredicate pred s ) && ( examineFields ( idx + 1 ) preds ss )
Nothing -> examineFields ( idx + 1 ) preds ss

अब मुझे लगता है कि समारोह examineFields के माध्यम से किया जा सकता था foldr , लेकिन यह, है विस्तार।

सामान्य तौर पर, मैं किए गए काम से प्रसन्न हूं। यह दुर्लभ है - लेकिन मुझे NgnTraffic कोड भी पसंद है। और मुझे विशेष रूप से प्रगति पसंद है जो एक ही कार्यक्रम के उदाहरण पर दिखाई देती है, जो अलग-अलग समय पर और अलग-अलग ज्ञान के साथ लिखी गई है। और "इससे भी अधिक विशेष" मुझे यह पसंद है कि यह वास्तविक उत्पादन में इस्तेमाल हास्केल पर एक वास्तविक कार्यक्रम है ।

कोई फर्क नहीं पड़ता कि वे क्या कहते हैं, हास्केल एक भयानक भाषा है, सबसे अच्छा मैंने कभी भी साथ काम किया है।

संशोधन के लिए पार्सर स्रोत: [२] , [६] , [१२]
विलय के स्रोत (विलय एकीकृत कार्यक्रम सहित): [१३] , [१४] , [१६] , [२३] [२३]
NgnTraffic

PS के स्रोत अभी भी दूसरे मोनाद ट्यूटोरियल के अगले भाग का अनुवाद बहुत जल्द होगा।
पीपीएस ने कार्यक्रमों के लिंक को सही किया, जो कामरेड स्टेक के लिए धन्यवाद । PPPS
ने कामरेड गोडर और जैकहैब की बदौलत कुछ त्रुटियों को ठीक किया ।