मैं कैसे बात से मुक्त करने के लिए शैली

Question

दो तर्क का एक Haskell समारोह को फिर से लिखना कर रहा है हास्केल में निम्नलिखित समारोह

agreeLen :: (Eq a) => [a] -> [a] -> Int 
agreeLen x y = length $ takeWhile (\(a,b) -> a == b) (zip x y) 

मैं कैसे लिखने के लिए 'मुहावरेदार' हास्केल है, जो लगता है जानने के लिए कोशिश कर रहा हूँ . और $ कोष्ठक के बजाय, और जहां भी संभव हो पॉइंटफ्री कोड पसंद करना पसंद करते हैं। मैं स्पष्ट रूप से x और y का उल्लेख करने से छुटकारा नहीं पा रहा हूं। कोई विचार?

मुझे लगता है कि मुझे दो तर्कों के किसी भी फ़ंक्शन को पॉइंटफ्रीइंग के साथ एक ही समस्या होगी।

बीटीडब्ल्यू, यह सिर्फ अच्छे कोड लिखने की तलाश में है; कुछ "होमवर्क व्यायाम" इसे पॉइंटफ्री बनाने के लिए जो कुछ भी लेता है उसका उपयोग करें।

धन्यवाद।

---

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

Answer 1

और जहां भी संभव हो पॉइंटफ्री कोड पसंद करते हैं।

"जहां संभव हो" नहीं, लेकिन "जहां यह पठनीयता में सुधार करता है (या अन्य प्रकट फायदे हैं)"।

बात से मुक्त करने के लिए अपने

agreeLen x y = length $ takeWhile (\(a,b) -> a == b) (zip x y) 

एक पहला कदम ($) सही स्थानांतरित करने के लिए, और की जगह एक तुम एक (.) साथ होगा: अब

agreeLen x y = length . takeWhile (\(a,b) -> a == b) $ zip x y 

, आप इसे ले जा सकते हैं और भी सही:

agreeLen x y = length . takeWhile (uncurry (==)) . zip x $ y 

और वहां आप तुरंत काट सकते हैं एक तर्क बंद,

agreeLen x = length . takeWhile (uncurry (==)) . zip x 

तो फिर तुम कि पुनर्लेखन कर सकते हैं रचना ऑपरेटर का एक उपसर्ग आवेदन के रूप में,

agreeLen x = (.) (length . takeWhile (uncurry (==))) (zip x) 

और आप लिख सकते हैं

च (gx)

रूप

f . g $ x 

आम तौर पर,

f = (.) (length . takeWhile (uncurry (==))) 

और g = zip के साथ यहाँ,

agreeLen x = ((.) (length . takeWhile (uncurry (==)))) . zip $ x 

तर्क x आसानी से निकाल दिया जाता है जहाँ से दे रही है। तो फिर तुम एक वर्ग में (.) का उपसर्ग आवेदन बदल सकता है और

agreeLen = ((length . takeWhile (uncurry (==))) .) . zip 

मिलता लेकिन, कि मूल की तुलना में कम पढ़ी जा सकती है, तो मैं कर सलाह नहीं देते में भाव के परिवर्तन का अभ्यास के लिए छोड़कर बिंदु से मुक्त है कि अंदाज।

Answer 2

रहे हैं:

agreeLen :: (Eq a) => [a] -> [a] -> Int 
agreeLen x y = length $ takeWhile id $ zipWith (==) x y 

मुहावरेदार हास्केल जो कुछ भी पढ़ने में आसान है, जरूरी नहीं कि क्या है सबसे अधिक बिंदु मुक्त।