हास्केल जेनेरिक प्रकार पैरामीटर रिसोल्वर टूल या विधि [डुप्लिकेट]
आइए इन कार्यों के प्रकारों को उदाहरण के लिए देखें:
:t traverse
traverse
:: (Applicative f, Traversable t) => (a -> f b) -> t a -> f (t b)
:t id
id :: a -> a
वे कोई ठोस प्रकार है, लेकिन है सामान्य प्रकार पैरामीटर : a
, f
, b
, t
(मुझे ठीक कर लें उन्हें कॉल नहीं सामान्य प्रकार पैरामीटर कृपया)
अगर मैं गठबंधन id
और traverse
एक साथ इस तरह से,
:t traverse id [Just 1, Just 2, Nothing]
traverse id [Just 1, Just 2, Nothing] :: Num b => Maybe [b]
हास्केल अब प्रकार चर के लिए कुछ ठोस प्रकार बाध्य कर सकते हैं a
, f
, b
, t
।
t = []
a = Maybe bb
f = Maybe
b = Num bb => bb
नीचे मैं हाथ से मापदंडों के प्रकार और मैपिंग का अनुमान लगाता हूं, क्या हास्केल में कोई भी तरीका या उपकरण स्वचालित रूप से ऐसा करने के लिए है, ताकि यह उदाहरण में कुछ रचित भागों ( id
और traverse
) को ले जाए, सामान्य रूप से उनके प्रकार के हस्ताक्षर निकालता है, और आउटपुट पर उत्पादन करता है जेनेरिक प्रकार के मापदंडों के नाम से लेकर ठोस अनुमानों तक की मैपिंग?
पहला उदाहरण यहां भी देखें: https://wiki.haskell.org/Type_inferenceअभिव्यक्ति के लिए " map ord
" कैसे हास्केल को वास्तविक प्रकार के नामों से बाइंडिंग मिलती है।
तो जब हम कार्यों को देखने के लिए अलग से हम केवल नाम है a
, f
, b
, t
। लेकिन तब हम गठबंधन कार्य करता है और जैसे कुछ अतिरिक्त जानकारी प्रदान करते हैं [Just 1, Just 2, Nothing]
, और नाम a
, f
, b
, t
ठोस प्रकार के लिए मैप की जाती हैं।
मैं इस मैपिंग को स्वचालित रूप से पकड़ना और दिखाना चाहता हूं।
जवाब
मुझे लगता है कि f
और t
अधिक कर रहे हैं सामान्य प्रकार निर्माता मानकों , के रूप में वे एक प्रकार से कार्रवाई आप एक प्रकार देने के लिए (वे तरह है * -> *
, जहां *
का अर्थ है "एक ठोस प्रकार")।
traverse id
नहीं संरचना, यह समारोह अनुप्रयोग है के रूप में आप गुजर रहे हैं है id
एक के रूप में तर्क करने के लिए traverse
। this . that
के बीच समारोह रचना है this
और that
गणितीय अर्थ, जहां आप एक समारोह है कि के लिए एक इनपुट के रूप में अपनी (प्रथम) तर्क देता है बनाने में, that
और के लिए इस आवेदन का परिणाम खिलाती this
।
आप इस पृष्ठ में उदाहरण का उल्लेख करते हैं , जहां यह दिया गया है
map :: (a -> b) -> [a] -> [b]
Char.ord :: (Char -> Int)
संकलक यह कटौती करने में सक्षम है कि किस प्रकार का map ord
है [Char] -> [Int]
, जैसा कि आप :t map ord
कमांड लाइन पर लिखकर स्वयं की जांच कर सकते हैं ।
यदि आप टाइप करते समय कंसर्ट के प्रकारों के साथ एक समान आउटपुट की उम्मीद करते हैं :t traverse id
, तो आप इसे प्राप्त नहीं कर पाएंगे, साधारण कारण के लिए जो traverse id
अभी भी एक बहुरूपी फ़ंक्शन है, दोनों में इसके ठोस प्रकार के तर्क और प्रकार के कंस्ट्रक्टर तर्क।
बस थोड़ा अलग उदाहरण देने के लिए, यदि आप टाइप करते हैं :t traverse (:[])
, जहां (:[])
प्रकार है a -> [a]
, जो (Applicative f) => a -> f b
उस traverse
अपेक्षा का एक विशेष मामला है, तो आपको यह आउटपुट मिलता है,
traverse (:[]) :: Traversable t => t b -> [t b]
जिसकी तुलना में :t traverse
,
traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
आपको बताता है कि traverse
, में traverse (:[])
, के साथ f === []
और "त्वरित" किया गया है a === b
।