मैं डिट्रिच एप के साथ सहमत हूं: यह कई चीजों का संयोजन है जो जीएचसी को तेज बनाते हैं।
और सबसे पहले, हास्केल बहुत उच्च-स्तरीय है। यह संकलक को आपके कोड को तोड़ने के बिना आक्रामक अनुकूलन करने में सक्षम बनाता है ।
SQL के बारे में सोचो। अब, जब मैं एक SELECTबयान लिखता हूं , तो यह एक अनिवार्य लूप की तरह लग सकता है , लेकिन ऐसा नहीं है । ऐसा लग सकता है कि यह उस तालिका की सभी पंक्तियों पर लूप करता है जो निर्दिष्ट शर्तों से मेल खाने वाले को खोजने की कोशिश कर रहा है, लेकिन वास्तव में "कंपाइलर" (डीबी इंजन) इसके बजाय एक इंडेक्स लुकअप कर सकता है - जिसमें पूरी तरह से अलग प्रदर्शन विशेषताएं हैं। लेकिन चूँकि SQL इतना उच्च-स्तर का है, इसलिए "कंपाइलर" पूरी तरह से अलग एल्गोरिदम को स्थानापन्न कर सकता है, कई प्रोसेसर या I / O चैनल या पूरे सर्वर को पारदर्शी रूप से लागू कर सकता है, और बहुत कुछ।
मैं हास्केल को एक जैसा मानता हूं। आप सोच सकते हैं कि आपने हास्केल को इनपुट सूची को दूसरी सूची में मैप करने के लिए कहा था, दूसरी सूची को तीसरी सूची में फ़िल्टर करें, और फिर गणना करें कि कितने आइटम हुए। लेकिन आपने देखा नहीं कि जीएचसी दृश्यों के पीछे धारा-संलयन पुनर्लेखन नियम लागू करता है, पूरी चीज़ को एकल तंग मशीन कोड लूप में बदल देता है जो कि बिना आवंटन के डेटा के साथ एक ही पास में पूरी नौकरी करता है - जिस तरह की चीज़ थकाऊ, त्रुटि-प्रवण और हाथ से लिखने के लिए गैर-रखरखाव योग्य। कोड में निम्न-स्तरीय विवरणों की कमी के कारण यह वास्तव में संभव है।
इसे देखने का एक और तरीका हो सकता है ... हास्केल को तेज क्यों नहीं होना चाहिए ? यह क्या करता है कि इसे धीमा करना चाहिए?
यह पर्ल या जावास्क्रिप्ट जैसी व्याख्या वाली भाषा नहीं है। यह जावा या C # जैसी वर्चुअल मशीन प्रणाली भी नहीं है। यह देशी मशीन कोड के लिए नीचे सभी तरह से संकलित करता है, इसलिए कोई उपरि नहीं है।
OO भाषाओं के विपरीत [जावा, C #, जावास्क्रिप्ट…], हास्केल में पूर्ण प्रकार का क्षरण होता है [जैसे C, C ++, पास्कल…]। सभी प्रकार की जाँच केवल संकलन-समय पर होती है। इसलिए आपको धीमा करने के लिए कोई रन-टाइम टाइप-चेकिंग नहीं है। (उस मामले के लिए कोई नल-पॉइंटर चेक नहीं है। जावा, जेवीएम को अशक्त बिंदुओं की जांच करनी चाहिए और यदि आप एक को टालते हैं तो अपवाद को फेंक दें। हास्केल को उस चेक से परेशान नहीं होना चाहिए।)
आप कहते हैं कि यह "रन-टाइम में फ़्लाई पर फ़ंक्शंस बनाने" में धीमा लगता है, लेकिन यदि आप बहुत ध्यान से देखते हैं, तो आप वास्तव में ऐसा नहीं करते हैं। यह आप की तरह लग सकता है, लेकिन आप नहीं करते। यदि आप कहते हैं (+5), ठीक है, कि आपके स्रोत कोड में हार्ड-कोडित है। यह रन-टाइम में नहीं बदल सकता। तो यह वास्तव में एक गतिशील कार्य नहीं है। यहां तक कि करीकृत कार्य वास्तव में सिर्फ डेटा ब्लॉक में मापदंडों को बचा रहे हैं। सभी निष्पादन योग्य कोड वास्तव में संकलन-समय पर मौजूद हैं; कोई रन-टाइम व्याख्या नहीं है। (कुछ अन्य भाषाओं के विपरीत, जिनमें "eval function" है।)
पास्कल के बारे में सोचो। यह पुराना है और कोई भी वास्तव में इसका उपयोग नहीं करता है, लेकिन कोई भी शिकायत नहीं करेगा कि पास्कल धीमा है । इसके बारे में नापसंद करने के लिए बहुत सारी चीजें हैं, लेकिन धीमेपन वास्तव में उनमें से एक नहीं है। हास्केल वास्तव में ऐसा नहीं कर रहा है जो मैनुअल मेमोरी प्रबंधन के बजाय कचरा संग्रह करने के अलावा पास्कल के लिए अलग है। और अपरिवर्तनीय डेटा जीसी इंजन के लिए कई अनुकूलन की अनुमति देता है [जो आलसी मूल्यांकन फिर कुछ हद तक जटिल होता है]।
मुझे लगता है कि बात यह है कि हास्केल उन्नत और परिष्कृत और उच्च-स्तरीय दिखता है, और हर कोई सोचता है कि "अरे वाह, यह वास्तव में शक्तिशाली है, यह आश्चर्यजनक रूप से धीमा होना चाहिए! " लेकिन यह नहीं है। या कम से कम, यह उस तरह से नहीं है जैसा आप उम्मीद करेंगे। हां, यह एक अद्भुत प्रकार की प्रणाली है। लेकिन आप जानते हैं कि क्या? यह सब संकलन-समय पर होता है। रन-टाइम तक, यह चला गया। हां, यह आपको कोड की एक पंक्ति के साथ जटिल ADTs बनाने की अनुमति देता है। लेकिन आप जानते हैं कि क्या? एक ADT सिर्फ सादा साधारण सी unionहै struct। और कुछ नहीं।
असली हत्यारा आलसी मूल्यांकन है। जब आपको अपने कोड की कठोरता / आलस्य मिलता है, तो आप मूर्खतापूर्ण तेज़ कोड लिख सकते हैं जो अभी भी सुरुचिपूर्ण और सुंदर है। लेकिन अगर आपको यह सामान गलत लगता है, तो आपका कार्यक्रम हजारों बार धीमा हो जाता है , और यह वास्तव में गैर-स्पष्ट है कि ऐसा क्यों हो रहा है।
उदाहरण के लिए, मैंने यह गिनने के लिए एक तुच्छ सा प्रोग्राम लिखा कि एक फाइल में कितनी बार प्रत्येक बाइट दिखाई देती है। 25KB इनपुट फ़ाइल के लिए, प्रोग्राम को चलाने में 20 मिनट लगे और 6 गीगाबाइट रैम को निगल लिया ! वह बेतुका है !! लेकिन तब मुझे एहसास हुआ कि समस्या क्या थी, एक एकल बैंग-पैटर्न जोड़ा, और रन-टाइम 0.02 सेकंड तक गिरा ।
यह वह जगह है जहां हास्केल अप्रत्याशित रूप से धीरे-धीरे जाता है। और यह निश्चित है कि इसकी आदत पड़ने में थोड़ा समय लगता है। लेकिन समय के साथ, वास्तव में तेज कोड लिखना आसान हो जाता है।
हास्केल इतनी तेजी से क्या करता है? पवित्रता। स्थैतिक प्रकार। आलस्य। लेकिन इन सबसे ऊपर, पर्याप्त रूप से उच्च-स्तरीय होना कि संकलक आपके कोड की अपेक्षाओं को तोड़ने के बिना कार्यान्वयन को मौलिक रूप से बदल सकता है।
लेकिन मुझे लगता है कि यह सिर्फ मेरी राय है ...