हास्केल समझ प्रवाह

Question

मैं Haskell करने के लिए, मैं एक स्ट्रिंग विभाजन समारोह

delim = '|' 
splitStr::[Char]->[[Char]]->[[Char]] 
splitStr list y     
       | sL > 0 && sL < length(list) = splitStr (drop (sL+1) list) [subList]++y 
       | otherwise = [subList]++y 
       where 
        subList = takeWhile (\x -> x /= delim) list 
        sL = length(subList) 

split s = splitStr s [] 

लिखने के लिए कोशिश कर रहा था लेकिन नए हूँ, इसके बाद के संस्करण कोड हमेशा स्ट्रिंग उलटे क्रम

Main> split "foo|bar|java|python" 
["python","java","bar","foo"] 

से बदलने में रिटर्न y++[subList] से [subList]++y अभी भी वही परिणाम देता है। मुझे पता है कि ऐसा करने के लिए शायद बेहतर तरीके हैं, लेकिन मैं जानना चाहता हूं कि उपर्युक्त क्यों हो रहा है।

Answer 1

splitStr (drop (sL+1) list) [subList]++y 

यह (splitStr (drop (sL+1) list) [subList])++y के रूप में पार्स किया जाता है। आप जो चाहते थे वह शायद splitStr (drop (sL+1) list) ([subList]++y) है।

Answer 2

यहाँ, क्या कहा sepp2k करने के लिए अतिरिक्त है, कैसे अपने कोड में सुधार करने के बारे में कुछ:

अपने कोड में आप एक संचायक की जरूरत नहीं है, क्योंकि आप कोड आलस्य दोहन कर सकते हैं। मैं आपके कोड को फिर से लिखता हूं जैसे कि मैं इसे करूंगा:

split :: Char -> String -> [String] 
split delim "" = [] 
split delim s = chunk : split delim rest where 
(chunk,_:rest) = break (==delim) s 

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