हास्केल फ़ंक्शन के प्रकार के लिए तीरों का उपयोग क्यों करता है?

Question

मैंने अभी हास्केल सीखना शुरू किया और मेरे लिए अजीब चीजों में से एक है कई तर्कों के साथ एक समारोह के प्रकार के लिए वाक्यविन्यास।

एक सरल उदाहरण पर विचार करें:

(+) :: Num a => a -> a -> a 

क्यों हम सभी तीर यहाँ की ज़रूरत है? Num Num Num -> Num जैसे कुछ लिखने के लिए और अधिक समझदारी नहीं होगी?

हुड के नीचे क्या कारण है? मैंने इस सवाल की खोज की लेकिन वास्तव में कुछ भी उपयोगी नहीं मिला।

Answer 1

चीजों को भ्रमित करने वाली पहली चीज़ Num a => है, इसलिए हम इसे पूरी तरह से अनदेखा कर देंगे। इसके बजाए, Int -> Int -> Int पर विचार करें, जो आपके द्वारा दिए गए प्रकार के हस्ताक्षर का एक संभावित विशेषज्ञता है।

फ़ंक्शन लगभग हमेशा curried हास्केल में हैं। इसका मतलब है कि एक बहु-तर्क फ़ंक्शन वास्तव में एक तर्क का कार्य करता है जो एक फ़ंक्शन देता है जो अगली तर्क लेता है, और इसी तरह।

-> सही सहयोगी है, इसलिए Int -> Int -> IntInt -> (Int -> Int) जैसा ही है।

यह भी मतलब है कि इस परिभाषा

f :: Int -> Int -> Int 
f x y = x + y 

f :: Int -> Int -> Int 
f x = \y -> x + y 

वास्तव में रूप में ही है, हास्केल में सभी कार्यों ठीक एक तर्क ले। टुपल्स भी मौजूद हैं, लेकिन वे प्रथम श्रेणी के नागरिक हैं, इसलिए वे सिर्फ एक तर्क सूची से अधिक हैं।

Num a => टाइप सिस्टम का एक अलग पहलू है। यह कहता है कि प्रकार परिवर्तनीय aNum प्रकार वर्ग का एक उदाहरण होना चाहिए। Num के उदाहरणों के सामान्य उदाहरण Int और Double शामिल हैं। तो Num एक प्रकार का नहीं है, यह एक प्रकार का वर्ग है। Num a => प्रकार परिवर्तनीय a पर एक बाधा का प्रतिनिधित्व करता है, यह फ़ंक्शन के लिए एक और तर्क नहीं है। इसलिए आपको (+) का उपयोग करने के इस तरह से a विवश चाहिए

(+) विधि, Num प्रकार वर्ग का एक सदस्य है। यदि आप f हस्ताक्षर a -> a -> a (बिना किसी बाधा के) देने का प्रयास करते हैं, तो यह काम नहीं करेगा क्योंकि a पूरी तरह से अनियंत्रित है और हम इसके बारे में कुछ भी नहीं जानते हैं कि यह किस प्रकार हो सकता है। नतीजतन, हम (+) पर इसका उपयोग नहीं कर सके।

Answer 2

किसी फ़ंक्शन के प्रकार हस्ताक्षर में प्रत्येक तर्क के प्रकार में व्हाइटस्पेस हो सकता है, और इसलिए गैर-व्हाइटस्पेस सेपरेटर की सबसे अधिक आवश्यकता होती है ताकि संकलक (और इंसान!) उनके बीच अंतर कर सकें।

उदाहरण के लिए, यदि आप एक parameterised सार डेटा प्रकार हो सकते हैं:

data MyType a = MyValue a 

और एक समारोह है कि ठोस प्रकार लेता है (MyType प्रकार निर्माता से निर्मित):

myFunc :: MyType Int -> MyType Int -> String 

यदि आप नहीं था ' तर्कों के बीच -> नहीं है, हस्ताक्षर

myFunc :: MyType Int MyType Int -> String -- Not valid code 

जैसा दिखता है

और एक कंपाइलर को कार्य करने के वास्तविक तर्क क्या हैं (और मुझे आश्चर्य है कि कुछ मामलों में यह असंभव भी हो सकता है?)। कम से कम, यह बहुत कम समझ में आता है।