हास्केल का डेटा क्यों। List.deleteBy एक तुलनात्मक फ़ंक्शन (ए -> ए -> बूल) इनपुट और एक अनुमान (ए -> बूल) के बजाय एक मान लेता है?

Question

मेरे पास डेटा से संबंधित एक प्रश्न है। लिस्ट और deleteBy के हस्ताक्षर। आदर्श रूप से इस फ़ंक्शन को इनपुट में एक अनुमान लगाया जाना चाहिए और पहला तत्व हटा देना चाहिए जिसके लिए भविष्य सत्य है। कुछ की तरह:

deleteBy :: (a -> Bool) -> [a] -> [a] 
deleteBy p = go 
    where go []     = [] 
      go (x:xs) | p x   = xs 
        | otherwise = x:go xs 

इसके बजाय समारोह पुस्तकालय में परिभाषित दोनों एक विधेय और एक मूल्य लेता है:

deleteBy    :: (a -> a -> Bool) -> a -> [a] -> [a] 
deleteBy _ _ []  = [] 
deleteBy eq x (y:ys) = if x `eq` y then ys else y : deleteBy eq x ys 

यह देखने के लिए कि eq हमेशा x पहले तर्क के रूप में और x साथ प्रयोग किया जाता है आसान है ठीक हो गई है deleteBy में, इसलिए eq x के बजाय eq और x दोनों प्राप्त करने का कोई कारण नहीं है। इसके विपरीत, एक तत्व पर काम करने का अनुमान लगाकर आप भविष्यवाणी कर सकते हैं कि दो मानों की तुलना नहीं करते हैं, जैसे कि a या cons true जैसे छोटे कार्य के रूप में कार्य करता है। मेरा सवाल है: deleteBy इस तरह से लागू क्यों किया गया है?

Answer 1

deleteBy फ़ंक्शन delete का सामान्यीकरण है, इसलिए इसे delete पर एक बार देखने में मददगार है।

delete :: Eq a => a -> [a] -> [a] 

delete एक मूल्य Eq a => a, तो Eq उदाहरण से (==) का उपयोग कर [a] से है कि मूल्य के पहले घटना को हटा देता है लेता है।

सभी *ByData.List में कार्यों के साथ के रूप में, Eq बाधा हटा दिया है और प्रोग्रामर अपने स्वयं के प्रतिस्थापन (==) समारोह प्रदान करने के लिए आवश्यक है।

तो delete से Eq बाधा को दूर करने और (==), अर्थात् a -> a -> Bool के प्रकार और इसकी जगह, आप deleteBy के प्रकार देता है।

दूसरे शब्दों में, Data.List में शेष *By संचालन के साथ यह स्थिरता के लिए है।

Answer 2

सीडीके और अन्य बताते हैं। यह समानता भविष्यवाणी पर सामान्यीकृत करना है।

जो फ़ंक्शन आप मांग रहे हैं वह 'सूची में तत्वों को हटाएं जो इस predicate से मेल खाते हैं'। यह एकल तत्व filter के समान है।

deleteBy फ़ंक्शन 'तत्व हटाएं x है, लेकिन (==)' के बजाय इस तुलना ऑपरेटर का उपयोग करें।