प्वाइंट फ्री नोटेशन, रिकर्सन और पैटर्न मिलान

Question

इसलिए मैं पॉइंट फ्री प्रोग्रामिंग के बारे में बहुत कुछ सुनता रहता हूं और मैंने इसे समझने के लिए थोड़ा प्रयोग करने का फैसला किया। इसमें एक संख्या के फैक्टोरियल की गणना करने और इसे एक बिंदु-मुक्त रूप में परिवर्तित करने के लिए एक निश्चित कार्यवाही करना शामिल था। मैं इसे करने में कामयाब रहा, लेकिन बिंदु मुक्त परिणाम बिंदु परिणाम से बहुत कम पठनीय है।

-- pointed 
fact 0 = 1 
fact n = n * (fact (n-1)) 
-- point free 
fact' = foldr1 (*) . takeWhile ((<) 0) . iterate (flip (-) 1) 

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

Answer 1

pointfree रूप में विहित भाज्य है:

fact = product . enumFromTo 1 

(जो fact n = product [1..n] के बराबर है) मैं इस सुंदर पठनीय होने के लिए लगता है। हालांकि, मैं सहमत हूं कि मूल संस्करण:

fact 0 = 1 
fact n = n * (fact (n-1)) 

परिभाषा को बहुत अच्छी तरह से मेल खाता है और यह भी पठनीय है।

पॉइंटफ्री फॉर्म का बिंदु (हे!) अन्य कार्यों की संरचना के रूप में कार्यों के बारे में कारण बनाना आसान बनाता है। हालांकि, इस तरह के तर्क के लिए फैक्टोरियल फ़ंक्शन वास्तव में एक उत्कृष्ट उम्मीदवार नहीं है।

निर्णय आपका है, जाहिर है।

Answer 2

प्रत्येक बीजगणितीय संघ डेटा प्रकार के लिए इसके प्रकार के भेदभावकर्ता फ़ंक्शन मौजूद होना चाहिए जो उस प्रकार के मिलान पैटर्न को समाहित करता है। हम पहले से ही

either :: (a -> c) -> (b -> c) -> Either a b -> c 
maybe :: b -> (a -> b) -> Maybe a -> b 

इसी प्रकार वहाँ संख्या के लिए इस तरह के समारोह होना चाहिए,

num :: (Num a) => b -> (a -> b) -> a -> b 
num z nz 0 = z 
num z nz x = nz x 

तो हम

import Control.Applicative 
import Data.Function 

fact :: (Num a) => a -> a 
fact x = num 1 (\x-> (*) (fact (pred x)) x) x 
     = num 1 ((*) =<< (fact.pred)) x 

अर्थात

fact = (num 1 . ((*) =<<) . (. pred)) fact 
     = fix (num 1 . ((*) =<<) . (. pred))