मैं कुछ प्रोग्रामर्स को जानता हूं जो हास्केल के बारे में बात करते रहते हैं जब वे आपस में होते हैं, और यहां एसओ सभी को उस भाषा से प्यार करने लगता है। हास्केल का अच्छा होना कुछ हद तक एक जीनियस प्रोग्रामर की पहचान है।
क्या कोई हास्केल उदाहरण दे सकता है जो यह बताता है कि यह इतना सुरुचिपूर्ण / श्रेष्ठ क्यों है?
जवाबों:
जिस तरह से यह मेरे लिए पिच किया गया था, और जो मुझे लगता है कि एक महीने के लिए हास्केल पर सीखने पर काम करने के बाद अब सच है, यह तथ्य है कि कार्यात्मक प्रोग्रामिंग आपके मस्तिष्क को दिलचस्प तरीके से मोड़ती है: यह आपको विभिन्न तरीकों से परिचित समस्याओं के बारे में सोचने के लिए मजबूर करता है। : लूप्स के बजाय, नक्शे और सिलवटों और फिल्टर आदि के बारे में सोचें। सामान्य तौर पर, यदि आपके पास किसी समस्या पर एक से अधिक परिप्रेक्ष्य हैं, तो यह आपको इस समस्या के बारे में तर्क करने के लिए बेहतर बनाता है, और आवश्यक के रूप में दृष्टिकोण को स्विच करता है।
हास्केल के बारे में दूसरी बहुत ही साफ-सुथरी चीज है इसका टाइप सिस्टम। यह कड़ाई से टाइप किया गया है, लेकिन प्रकार का अनुमान इंजन इसे पायथन प्रोग्राम की तरह महसूस करता है जो आपको बेवकूफ टाइप-संबंधी गलती करने पर जादुई रूप से बताता है। इस संबंध में हास्केल के त्रुटि संदेशों में कुछ कमी है, लेकिन जैसा कि आप उस भाषा से अधिक परिचित हैं जो आप खुद से कहेंगे: यह वही है जो टाइपिंग माना जाता है!
यह वह जगह है उदाहरण है कि मुझे आश्वस्त हास्केल जानने के लिए (और लड़का हूँ मुझे खुशी है कि मैंने किया था)।
-- program to copy a file --
import System.Environment
main = do
--read command-line arguments
[file1, file2] <- getArgs
--copy file contents
str <- readFile file1
writeFile file2 strठीक है, यह एक छोटा, पठनीय कार्यक्रम है। इस लिहाज से यह C प्रोग्राम से बेहतर है। लेकिन यह एक समान संरचना के साथ एक पायथन कार्यक्रम से इतना अलग (कह) कैसे है?
इसका उत्तर आलसी मूल्यांकन है। अधिकांश भाषाओं (यहां तक कि कुछ कार्यात्मक वाले) में, ऊपर दिए गए एक प्रोग्राम की तरह पूरी फ़ाइल को मेमोरी में लोड किया जाएगा, और फिर एक नए नाम के तहत फिर से लिखा जाएगा।
हास्केल "आलसी" है। यह चीजों की तब तक गणना नहीं करता है जब तक कि उसे जरूरत न हो, और विस्तार से उन चीजों की गणना नहीं करता है जिनकी उसे कभी आवश्यकता नहीं है। उदाहरण के लिए, यदि आप writeFileलाइन को हटाते हैं , तो हास्केल पहली बार में फ़ाइल से कुछ भी पढ़ने से परेशान नहीं होगा।
जैसा कि यह है, हास्केल को पता चलता है कि इस writeFileपर निर्भर करता है readFile, और इसलिए इस डेटा पथ को अनुकूलित करने में सक्षम है।
हालांकि परिणाम संकलक-निर्भर होते हैं, जब आप उपरोक्त प्रोग्राम चलाते हैं तो आमतौर पर क्या होता है: यह प्रोग्राम पहली फाइल का एक ब्लॉक (8KB) पढ़ता है, फिर दूसरी फाइल पर लिखता है, फिर पहले से दूसरे ब्लॉक को पढ़ता है। फ़ाइल, और इसे दूसरी फ़ाइल पर लिखता है, और इसी तरह। (इस straceपर चलने की कोशिश करें !)
... जो एक फ़ाइल प्रतिलिपि के कुशल सी कार्यान्वयन क्या होगा की तरह एक बहुत कुछ दिखता है।
तो, हास्केल आपको बहुत अधिक प्रदर्शन का त्याग किए बिना - अक्सर कॉम्पैक्ट, पठनीय कार्यक्रम लिखने देता है।
एक और बात जो मुझे जोड़नी चाहिए वह यह है कि हास्केल बस छोटी गाड़ी के कार्यक्रमों को लिखना मुश्किल बना देता है। आश्चर्यजनक प्रकार प्रणाली, साइड-इफेक्ट्स की कमी, और निश्चित रूप से हास्केल कोड की कॉम्पैक्टनेस कम से कम तीन कारणों से बग को कम करती है:
बेहतर कार्यक्रम डिजाइन। कम जटिलता कम तर्क त्रुटियों की ओर जाता है।
कॉम्पैक्ट कोड। बग के लिए बहुत कम लाइनें मौजूद हैं।
संकलित त्रुटियाँ। कीड़े के बहुत सारे अभी मान्य हास्केल नहीं हैं ।
हास्केल हर किसी के लिए नहीं है। लेकिन सभी को इसे आज़माना चाहिए।
hSetBuffering handle (BlockBuffering (Just bufferSize))।
Data.Bytestring.Lazy.readFile) का उपयोग नहीं करते हैं, जिसका हस्केल का आलसी (गैर-सख्त) भाषा होने से कोई लेना-देना नहीं है। मोनाड्स अनुक्रमण कर रहे हैं - इसका अर्थ है "जब आप परिणाम निकालते हैं तो सभी दुष्प्रभाव होते हैं"। "आलसी बाइटस्ट्रिंग" जादू के रूप में: यह खतरनाक है, और आप इसे अन्य भाषाओं में समान या सरल वाक्य रचना के साथ कर सकते हैं।
readFileभी उसी तरह आलसी आईओ Data.ByteString.Lazy.readFileकरता है। तो जवाब गलत नहीं है, और यह केवल एक कंपाइलर अनुकूलन नहीं है। वास्तव में, यह हास्केल के लिए कल्पना का हिस्सा है : " readFileफ़ंक्शन एक फ़ाइल को पढ़ता है और फ़ाइल की सामग्री को एक स्ट्रिंग के रूप में लौटाता है। फ़ाइल को आलसी के रूप में, मांग पर, पढ़ा जाता है getContents।"
const fs = require('fs'); const [file1, file2] = process.argv.slice(2); fs.createReadStream(file1).pipe(fs.createWriteStream(file2)):। बैश में भी कुछ ऐसा ही है,:cat $1 > $2
आप गलत सवाल पूछने की तरह हैं।
हास्केल एक ऐसी भाषा नहीं है जहाँ आप कुछ शांत उदाहरणों को देखते हैं और जाते हैं "अहा, मैं अब देखता हूं, यही अच्छा बनाता है!"
यह अधिक पसंद है, हमारे पास इन सभी अन्य प्रोग्रामिंग भाषाएं हैं, और वे कमोबेश सभी समान हैं, और फिर हास्केल है जो पूरी तरह से अलग है और एक तरह से निराला है जो एक बार पूरी तरह से भयानक हो जाता है। लेकिन समस्या यह है कि, अपंगता के लिए काफी समय लगता है। ऐसी चीजें जो हास्केल को लगभग किसी भी अन्य अर्ध-मुख्यधारा की भाषा से अलग करती हैं:
साथ ही कुछ अन्य पहलू जो कई मुख्यधारा की भाषाओं से अलग हैं (लेकिन कुछ द्वारा साझा किए गए हैं):
जैसा कि कुछ अन्य पोस्टरों ने उत्तर दिया है, इन सभी विशेषताओं के संयोजन का मतलब है कि आप प्रोग्रामिंग के बारे में बिल्कुल अलग तरीके से सोचते हैं। और इसलिए यह एक उदाहरण (या उदाहरणों के सेट) के साथ आना मुश्किल है जो इसे जो-मुख्यधारा-प्रोग्रामर के लिए पर्याप्त रूप से संचार करता है। यह एक अनुभवात्मक बात है। (एक सादृश्य बनाने के लिए, मैं आपको अपनी 1970 की चीन यात्रा की तस्वीरें दिखा सकता हूँ, लेकिन फ़ोटो देखने के बाद, आप अभी भी नहीं जान पाएंगे कि उस दौरान वहाँ क्या हुआ था। इसी तरह, मैं आपको एक हास्केल दिखा सकता हूँ। 'क्विकसॉर्ट', लेकिन आप अभी भी नहीं जान पाएंगे कि हास्केलर होने का क्या मतलब है। '
वास्तव में हास्केल ने जो स्थापित किया है वह कार्यात्मक प्रोग्रामिंग को लागू करने के लिए अपने डिजाइन में किया गया प्रयास है। आप किसी भी भाषा में एक कार्यात्मक शैली में कार्यक्रम कर सकते हैं, लेकिन यह पहली सुविधा पर छोड़ देना बहुत आसान है। हास्केल आपको कार्यात्मक प्रोग्रामिंग का परित्याग करने की अनुमति नहीं देता है, इसलिए आपको इसे अपने तार्किक निष्कर्ष पर ले जाना चाहिए, जो एक अंतिम कार्यक्रम है जो इसके बारे में तर्क करना आसान है, और कांटों के प्रकारों के एक पूरे वर्ग को दरकिनार करता है।
जब वास्तविक दुनिया के उपयोग के लिए एक कार्यक्रम लिखने की बात आती है, तो आप हास्केल को कुछ व्यावहारिक फैशन में कमी पा सकते हैं, लेकिन हास्केल को शुरू करने के लिए आपका अंतिम समाधान बेहतर होगा। मैं निश्चित रूप से अभी तक वहां नहीं हूं, लेकिन अभी तक हस्केल सीखने से यह कहने की तुलना में अधिक ज्ञानवर्धक है, लिस्प कॉलेज में था।
unsafePerformIOउन लोगों के लिए जो सिर्फ दुनिया को जलते देखना चाहते हैं;)
उपद्रव का एक हिस्सा यह है कि शुद्धता और स्थैतिक टाइपिंग आक्रामक अनुकूलन के साथ संयुक्त समानता के लिए सक्षम करते हैं। समानांतर भाषाएं अभी बहुत गर्म हैं क्योंकि मल्टीकोर थोड़ा विघटनकारी है।
हास्केल आपको किसी भी सामान्य प्रयोजन की भाषा की तुलना में एक तेज, देशी कोड संकलक की तुलना में समानता के लिए अधिक विकल्प देता है। समानांतर शैलियों के लिए इस तरह के समर्थन के साथ वास्तव में कोई प्रतिस्पर्धा नहीं है:
इसलिए यदि आप अपने मल्टीकोर काम करने के बारे में परवाह करते हैं, तो हास्केल को कुछ कहना है। हास्केल में समानांतर और समवर्ती प्रोग्रामिंग पर साइमन पेटन जोन्स के ट्यूटोरियल के साथ शुरुआत करने के लिए एक शानदार जगह है ।
संगामिति से निपटने के लिए सॉफ्टवेयर ट्रांसेक्शनल मेमोरी एक अच्छा तरीका है। यह संदेश पारित करने की तुलना में बहुत अधिक लचीला है, और म्यूटेक्स की तरह गतिरोध प्रवण नहीं है। एसएचएम के जीएचसी के कार्यान्वयन को सर्वश्रेष्ठ में से एक माना जाता है।
मैंने पिछले वर्ष हास्केल सीखने और उसमें एक यथोचित बड़े और जटिल प्रोजेक्ट को लिखने में बिताया है। (यह परियोजना एक स्वचालित विकल्प ट्रेडिंग सिस्टम है, और ट्रेडिंग एल्गोरिदम से निचले स्तर तक के हाई-स्पीड मार्केट डेटा फीड्स के पार्सिंग और हैंडलिंग तक सब कुछ हास्केल में किया जाता है।) यह समझने के लिए बहुत अधिक संक्षिप्त और आसान है। एक जावा संस्करण की तुलना में उपयुक्त पृष्ठभूमि), साथ ही साथ बहुत मजबूत होगी।
संभवतः मेरे लिए सबसे बड़ी जीत मोनाडोइड, मोनाड्स, और इसी तरह की चीजों के माध्यम से नियंत्रण प्रवाह को संशोधित करने की क्षमता है। एक बहुत ही सरल उदाहरण ऑर्डरिंग मोनॉइड होगा; जैसे कि एक अभिव्यक्ति में
c1 `mappend` c2 `mappend` c3c1वापसी पर और कहाँ LT, EQया GT, c1लौटने EQसे अभिव्यक्ति का मूल्यांकन, मूल्यांकन जारी रखने का कारण बनता है c2; यदि c2रिटर्न LTया GTयह पूरे का मूल्य है, औरc3 मूल्यांकन नहीं किया गया है। इस तरह की चीज़ बहुत अधिक परिष्कृत और जटिल हो जाती है जैसे मैंडिक मैसेज जनरेटर और पार्सर्स, जहाँ मैं विभिन्न प्रकार के राज्य ले जा सकता हूँ, अलग-अलग गर्भपात की स्थिति होती है, या किसी विशेष कॉल के लिए निर्णय लेने में सक्षम हो सकता है कि क्या वास्तव में गर्भपात का मतलब है "आगे की प्रक्रिया नहीं है" या इसका मतलब है, "अंत में एक त्रुटि लौटाएं, लेकिन आगे के त्रुटि संदेश एकत्र करने के लिए प्रसंस्करण जारी रखें।"
यह सब सामान है जिसमें कुछ समय लगता है और शायद सीखने के लिए काफी कुछ प्रयास करना पड़ता है, और इस प्रकार यह उन लोगों के लिए एक ठोस तर्क बनाना कठिन हो सकता है जो पहले से इन तकनीकों को नहीं जानते हैं। मुझे लगता है कि ऑल अबाउट मोनड्स ट्यूटोरियल इस के एक पहलू का बहुत प्रभावशाली प्रदर्शन करता है, लेकिन मैं यह उम्मीद नहीं करूंगा कि कोई भी पहले से मौजूद सामग्री से परिचित नहीं है या पहले, या तीसरे, सावधान पढ़ने पर "मिलेगा"।
वैसे भी, हास्केल में बहुत सारे अन्य अच्छे सामान हैं, लेकिन यह एक प्रमुख है जिसे मैंने इतनी बार उल्लेख नहीं किया है, शायद इसलिए कि यह बहुत जटिल है।
एक दिलचस्प उदाहरण के लिए आप यहां देख सकते हैं: http://en.literateprograms.org/Quicksort_(Haskell)
विभिन्न भाषाओं में कार्यान्वयन को देखने के लिए क्या दिलचस्प है।
हास्केल क्या दिलचस्प बनाता है, अन्य कार्यात्मक भाषाओं के साथ, यह तथ्य है कि आपको प्रोग्राम कैसे करना है, इसके बारे में अलग तरह से सोचना होगा। उदाहरण के लिए, आप आमतौर पर छोरों के लिए या उसके बाद का उपयोग नहीं करेंगे, लेकिन पुनरावृत्ति का उपयोग करेंगे।
जैसा कि ऊपर उल्लेख किया गया है, हास्केल और अन्य कार्यात्मक भाषाएं मल्टी-कोर पर काम करने के लिए समानांतर प्रसंस्करण और लेखन अनुप्रयोगों के साथ उत्कृष्ट हैं।
मैं आपको एक उदाहरण नहीं दे सकता, मैं एक OCaml लड़का हूं, लेकिन जब मैं खुद के साथ ऐसी स्थिति में हूं, तो जिज्ञासा बस पकड़ लेती है और मुझे एक कंपाइलर / दुभाषिया डाउनलोड करना पड़ता है और इसे देना पड़ता है। आप संभवतः किसी दिए गए कार्यात्मक भाषा की ताकत और कमजोरियों के बारे में और अधिक सीखेंगे।
एल्गोरिदम या गणितीय समस्याओं से निपटने के दौरान एक बात मुझे बहुत अच्छी लगती है कि हास्केल की गणनाओं का अंतर्निहित आलसी मूल्यांकन है, जो केवल इसकी सख्त कार्यात्मक प्रकृति के कारण ही संभव है।
उदाहरण के लिए, यदि आप सभी primes की गणना करना चाहते हैं, तो आप उपयोग कर सकते हैं
primes = sieve [2..]
where sieve (p:xs) = p : sieve [x | x<-xs, x `mod` p /= 0]और परिणाम वास्तव में एक अनंत सूची है। लेकिन हास्केल इसे दाएं से बाएं का मूल्यांकन करेगा, इसलिए जब तक आप कुछ ऐसा करने की कोशिश नहीं करते हैं, जिसे पूरी सूची की आवश्यकता होती है, तब भी आप इसे प्रोग्राम के बिना उपयोग कर सकते हैं, जैसे कि अनंत में अटक जाना।
foo = sum $ takeWhile (<100) primesजो सभी 100 से कम primes गाया जाता है। यह कई कारणों से अच्छा है। सबसे पहले, मुझे केवल एक ही प्राइम फंक्शन लिखना होगा जो सभी प्राइम्स को जनरेट करता है और फिर मैं प्राइम्स के साथ काम करने के लिए बहुत ज्यादा तैयार हूं। ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषा में, मुझे फ़ंक्शन को यह बताने के लिए किसी तरह की आवश्यकता होगी कि लौटने से पहले कितने प्राइम की गणना करनी चाहिए या किसी वस्तु के साथ अनंत सूची व्यवहार का अनुकरण करना चाहिए। एक और बात यह है कि सामान्य तौर पर, आप लेखन कोड को समाप्त करते हैं जो व्यक्त करता है कि आप क्या गणना करना चाहते हैं और किन चीजों का मूल्यांकन करने के लिए नहीं - इसके बजाय संकलक आपके लिए ऐसा करता है।
यह न केवल अनंत सूचियों के लिए उपयोगी है, वास्तव में इसका उपयोग आपके बिना हर समय यह जानने के बिना हो जाता है जब आवश्यकता से अधिक मूल्यांकन करने की आवश्यकता नहीं होती है।
मैं दूसरों से सहमत हूं कि कुछ छोटे उदाहरणों को देखना हास्केल को दिखाने का सबसे अच्छा तरीका नहीं है। लेकिन मैं कुछ भी दे दूँगा। यहां यूलर प्रोजेक्ट की समस्याओं का हल 18 और 67 में दिया गया है , जो आपको एक त्रिकोण के शीर्ष पर आधार से अधिकतम-राशि का रास्ता खोजने के लिए कहता है:
bottomUp :: (Ord a, Num a) => [[a]] -> a
bottomUp = head . bu
where bu [bottom] = bottom
bu (row : base) = merge row $ bu base
merge [] [_] = []
merge (x:xs) (y1:y2:ys) = x + max y1 y2 : merge xs (y2:ys)यहाँ Lesh और Mitzenmacher द्वारा बुलबुला खोज एल्गोरिथ्म का एक पूर्ण, पुन: प्रयोज्य कार्यान्वयन है । मैंने इसका उपयोग डीवीडी पर संग्रहणीय संग्रहण के लिए बड़ी मीडिया फ़ाइलों को बिना कचरे के पैक करने के लिए किया:
data BubbleResult i o = BubbleResult { bestResult :: o
, result :: o
, leftoverRandoms :: [Double]
}
bubbleSearch :: (Ord result) =>
([a] -> result) -> -- greedy search algorithm
Double -> -- probability
[a] -> -- list of items to be searched
[Double] -> -- list of random numbers
[BubbleResult a result] -- monotone list of results
bubbleSearch search p startOrder rs = bubble startOrder rs
where bubble order rs = BubbleResult answer answer rs : walk tries
where answer = search order
tries = perturbations p order rs
walk ((order, rs) : rest) =
if result > answer then bubble order rs
else BubbleResult answer result rs : walk rest
where result = search order
perturbations :: Double -> [a] -> [Double] -> [([a], [Double])]
perturbations p xs rs = xr' : perturbations p xs (snd xr')
where xr' = perturb xs rs
perturb :: [a] -> [Double] -> ([a], [Double])
perturb xs rs = shift_all p [] xs rs
shift_all p new' [] rs = (reverse new', rs)
shift_all p new' old rs = shift_one new' old rs (shift_all p)
where shift_one :: [a] -> [a] -> [Double] -> ([a]->[a]->[Double]->b) -> b
shift_one new' xs rs k = shift new' [] xs rs
where shift new' prev' [x] rs = k (x:new') (reverse prev') rs
shift new' prev' (x:xs) (r:rs)
| r <= p = k (x:new') (prev' `revApp` xs) rs
| otherwise = shift new' (x:prev') xs rs
revApp xs ys = foldl (flip (:)) ys xsमुझे यकीन है कि यह कोड रैंडम जिबरिश जैसा दिखता है। लेकिन अगर आप मिटज़ेनमाकर के ब्लॉग प्रविष्टि को पढ़ते हैं और एल्गोरिदम को समझते हैं, तो आप आश्चर्यचकित होंगे कि एल्गोरिथ्म को कोड में पैकेज करना संभव है, इसके बारे में कुछ भी कहे बिना आप जो खोज रहे हैं।
आपके द्वारा पूछे जाने पर आपको कुछ उदाहरण देते हुए, मैं कहूंगा कि हास्केल की सराहना करने के लिए शुरू करने का सबसे अच्छा तरीका उस पेपर को पढ़ना है जिसने मुझे डीवीडी पैकर लिखने के लिए आवश्यक विचार दिए: जॉन ह्यूजेस द्वारा कार्यात्मक प्रोग्रामिंग मैटर्स क्यों । पेपर वास्तव में हास्केल को दर्शाता है, लेकिन यह कुछ ऐसे विचारों की व्याख्या करता है जो हास्केल जैसे लोगों को बनाते हैं।
मेरे लिए, हास्केल का आकर्षण संकलक गारंटी शुद्धता का वादा है । भले ही यह कोड के शुद्ध भागों के लिए हो।
मैं वैज्ञानिक सिमुलेशन कोड का एक बहुत कुछ लिखा है, और आश्चर्य होता है इसलिए होगा कि मेरे पहले कोड में एक बग, जो वर्तमान बहुत काम गलत हो सकते हैं था कई बार।
मुझे लगता है कि कुछ कार्यों के लिए मैं हास्केल के साथ अविश्वसनीय रूप से उत्पादक हूं।
इसका कारण सक्सेस सिंटेक्स और परीक्षण में आसानी है।
यह फ़ंक्शन फ़ंक्शन सिंटैक्स की तरह है:
foo a = 5
यह सबसे आसान तरीका है कि मैं एक फ़ंक्शन को परिभाषित करने के बारे में सोच सकता हूं।
अगर मैं उलटा लिखूं
inverseFoo a = a - 5
मैं देख सकता हूँ कि यह किसी भी यादृच्छिक इनपुट के लिए लिखकर उलटा है
prop_IsInverse :: डबल ->
बूल Prop_IsInverse a = a == (inverseFoo $ foo a)
और कमांड लाइन से कॉल करना
jonny @ ubuntu: runhaskell quickCheck + नाम fooFileName.hs
जो यह जांच करेगा कि मेरी फ़ाइल की सभी संपत्तियां बेतरतीब ढंग से इनपुट का परीक्षण करके आयोजित की गई हैं।
मुझे नहीं लगता कि हास्केल हर चीज के लिए सही भाषा है, लेकिन जब छोटे कार्यों और परीक्षण की बात आती है, तो मैंने कुछ भी बेहतर नहीं देखा है। यदि आपके प्रोग्रामिंग में गणितीय घटक है तो यह बहुत महत्वपूर्ण है।
यदि आप हास्केल में प्रकार प्रणाली के चारों ओर अपना सिर लपेट सकते हैं, तो मुझे लगता है कि अपने आप में एक उपलब्धि है।
मैं उन लोगों से सहमत हूं जिन्होंने कहा कि कार्यात्मक प्रोग्रामिंग आपके मस्तिष्क को एक अलग कोण से प्रोग्रामिंग को देखने में मोड़ देता है। मैंने इसे केवल एक शौक़ीन व्यक्ति के रूप में इस्तेमाल किया है, लेकिन मुझे लगता है कि मैंने मूलभूत रूप से एक समस्या का तरीका बदल दिया है। मुझे नहीं लगता कि हास्केल (और पाइथन में सूची बोध का उपयोग करने वाले) का खुलासा किए बिना मैं LINQ के साथ लगभग उतना ही प्रभावी रहा होगा।
एक विरोधाभासी दृष्टिकोण को हवा देने के लिए: स्टीव येजे लिखते हैं कि हिंदुली-मिलनर भाषाओं में अच्छे सिस्टम लिखने के लिए आवश्यक लचीलेपन की कमी है :
एचएम बहुत सुंदर है, पूरी तरह से बेकार औपचारिक गणितीय अर्थ में। यह कुछ गणना का निर्माण बहुत अच्छी तरह से करता है; हास्केल, SML और OCaml में पाया जाने वाला पैटर्न मिलान प्रेषण विशेष रूप से उपयोगी है। अप्रत्याशित रूप से, यह कुछ अन्य सामान्य और अत्यधिक वांछनीय निर्माणों को अजीब रूप से सबसे अच्छे रूप में संभालता है, लेकिन वे उन परिदृश्यों को यह कहकर समझाते हैं कि आप गलत हैं, आप वास्तव में उन्हें नहीं चाहते हैं। तुम्हें पता है, ओह, सेटिंग चर जैसी चीजें।
हास्केल सीखने लायक है, लेकिन इसकी अपनी कमजोरियां हैं।