क्या जीएचसी संभव होने पर पॉलिमॉर्फिक इंडिकेशन को हटा देता है?

Question

showInt :: Int -> String 
showInt x = show x 

ऊपर कोड कॉल showInt शब्दकोश गुजर या उसे सीधे समारोह Show Int उदाहरण पर घोषित कॉल करता है?

मेरा मतलब है, क्या जीएचसी संभव होने पर जेनरेट कोड से पॉलीमोर्फिक इंडिकेशन को हटा देता है?

Answer 1

हां।

Foo.showInt :: GHC.Types.Int -> GHC.Base.String 
[... attributes omitted ...] 
Foo.showInt = GHC.Show.$fShowInt_$cshow 

आप देख सकते हैं, यह GHC.Show.$fShowInt_$cshow करने के लिए बस एक सीधा संदर्भ: यह उत्पन्न कोर GHC 7.4.2 का उपयोग कर रहा है।

क्या होता है अगर हम प्रकार हस्ताक्षर हटाने के साथ तुलना करें ताकि अनुमानित प्रकार Show a => a -> String बजाय प्रयोग किया जाता है:

Foo.showInt 
    :: forall a_aop. GHC.Show.Show a_aop => a_aop -> GHC.Base.String 
[... attributes omitted ...] 
Foo.showInt = 
    \ (@ a_aot) ($dShow_aou :: GHC.Show.Show a_aot) (x_a9Z :: a_aot) -> 
    GHC.Show.show @ a_aot $dShow_aou x_a9Z 

यहाँ है, यह एक तर्क $dShow_aou शब्दकोश लेता है और यह एक्सेसर समारोह GHC.Show.show का उपयोग करता को देखने के लिए परिणामी फ़ंक्शन को x_a9Z पर लागू करने से पहले इस शब्दकोश से उपयुक्त फ़ंक्शन।

कम से कम अवधारणा के पहले मामले में क्या होता है, यह है कि चूंकि ठोस प्रकार ज्ञात है, इसलिए जीएचसी उचित उदाहरण शब्दकोश के प्रत्यक्ष संदर्भ को तर्क के रूप में लेने के बजाय प्रत्यक्ष संदर्भ देता है। फिर, एक्सेसर, जो मूल रूप से केवल एक रिकॉर्ड लेबल है, को रेखांकित किया जा सकता है और उचित फ़ंक्शन के प्रत्यक्ष संदर्भ के साथ आप छोड़ दिए गए हैं।

Answer 2

जीएचसी ऐसा नहीं करता है। readibility के लिए एक नया बनाया प्रकार के बारे में सोचो:

type Vector = (Float, Float) 

GHC की तरह एक समारोह से Polymorphicism को हटा चाहते हैं:

(!+!) :: Vector -> Vector -> Vector 
(x1, y1) !+! (x2, y2) = (x1 + x2, y1 + y2) 

प्रकार बन जाएगा:

(!+!) :: (Float, Float) -> (Float, Float) -> (Float, Float) 

समारोह जाहिर है जबकि वेक्टर के विशेष रूप से।