प्रीलूड के शब्दों का कार्य अधिक सरल क्यों नहीं लिखा गया है?

Question

words प्रस्ताव पर विचार करें; यह वास्तव में आसान है और एक निम्नलिखित तरीके से यह लिख सकते हैं:

words' :: String -> [String] 
words' [] = [] 
words' str = before : words' (dropWhile isSpace after) where 
    (before, after) = break isSpace str 

हालांकि, मैंने देखा है कि अपने मूल प्रस्तावना कोड बहुत कम ... प्राकृतिक लगता है:

words     :: String -> [String] 
words s     = case dropWhile {-partain:Char.-}isSpace s of 
           "" -> [] 
           s' -> w : words s'' 
             where (w, s'') = 
              break {-partain:Char.-}isSpace s' 

मुझे लगता है देखते हैं कि इसके लिए अनुकूलन से संबंधित कारण। सवाल यह है: क्या मुझे उम्मीद है कि संकलक को words' फ़ंक्शन को इसके साथ ही इसके प्रीलूड संस्करण को अनुकूलित करना चाहिए? मैंने एक ही फ़ंक्शन का उपयोग किया (break, dropWhile, isSpace)।

मैं एक बार बहुत आश्चर्य है कि GHC सरल निम्न स्तर के अनुकूलन के कुछ का पालन नहीं किया था:

C vs Haskell Collatz conjecture speed comparison

लेकिन एक तरफ {-partain:Char.-} बिट के लिए (संकलक के लिए इस संकेत में बहुत सहायक प्रतीत नहीं होता इस स्थिति आईएमओ) words कोड एक उच्च स्तरीय भाषा के लिए अनावश्यक रूप से फूला हुआ लगता है। इस मामले में इसके पीछे क्या कारण है?

Answer 1

यह लगभग एक ही कोड है। केवल अंतर यह है कि यदि हम प्रत्येक कॉल या केवल रिकर्सिव कॉल से पहले dropWhile isSpace कर रहे हैं। न तो दूसरे की तुलना में अधिक जटिल है, बल्कि बाद वाले (प्रीलूड) संस्करण अधिक वर्बोज़ लगता है क्योंकि पैटर्न मिलान सीधे फ़ंक्शन में नहीं है।

तुम इतनी तरह अंतर (और क्यों प्रस्तावना संस्करण बेहतर व्यवहार है) का पालन कर सकते हैं:

*Main> words " " 
[] 
*Main> words' "  " 
[""] 

ध्यान दें कि आप जल्दी से सत्यापित कर सकते हैं, तो अपने "सुधार" संस्करण QuickCheck का उपयोग कर मूल के समान हैं।