हास्केल जेनेरिक प्रकार पैरामीटर रिसोल्वर टूल या विधि [डुप्लिकेट]

Dec 12 2020

आइए इन कार्यों के प्रकारों को उदाहरण के लिए देखें:

: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ठोस प्रकार के लिए मैप की जाती हैं।

मैं इस मैपिंग को स्वचालित रूप से पकड़ना और दिखाना चाहता हूं।

जवाब

Enlico Dec 12 2020 at 00:55

मुझे लगता है कि fऔर tअधिक कर रहे हैं सामान्य प्रकार निर्माता मानकों , के रूप में वे एक प्रकार से कार्रवाई आप एक प्रकार देने के लिए (वे तरह है * -> *, जहां *का अर्थ है "एक ठोस प्रकार")।

traverse idनहीं संरचना, यह समारोह अनुप्रयोग है के रूप में आप गुजर रहे हैं है idएक के रूप में तर्क करने के लिए traversethis . 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