2014-05-03 10 views
7

ठीक है, इसलिए यहाँ भाषा की एक अस्पष्ट कोने है:प्रकार हस्ताक्षर

हास्केल यदि आपने पहचानकर्ता जो हस्ताक्षर टाइप है निर्यात करने के लिए अनुमति देता है एक प्रकार है कि है नहीं निर्यात का उल्लेख है। इस के अर्थशास्त्र वास्तव में क्या है?

उदाहरण के लिए, मैं

module Foobar (bar) where 

data Foo = ... 

bar :: String -> Foo 

Foo निर्यात नहीं किया गया है लगता है bar है, जबकि। bar का प्रकार Foo का उल्लेख करता है। कई प्रोग्रामिंग भाषाएं आपको ऐसा करने नहीं देतीं, लेकिन हास्केल करता है।

तो अब क्या? ऐसा लगता है कि मैं bar पर कॉल कर सकता हूं, लेकिन इसके परिणाम के साथ बहुत कुछ नहीं कर सकता। मैं विशेष रूप से, मैं (संभवतः) परिणाम प्रकार का नाम नहीं बोल सकता, जो थोड़े अजीब है। संभवतः यदि मॉड्यूल ने कुछ कार्यों को निर्यात किया जो Foo इनपुट के रूप में लेते हैं, तो मुझे इनपुट के रूप में मेरे परिणाम के साथ उनको कॉल करने में सक्षम होना चाहिए ... फिर भी मैं पूरी तरह से एक प्रकार के हस्ताक्षर में ऐसा नहीं कह सकता।

निश्चित रूप से, उपरोक्त की तरह कुछ करना एक अच्छा विचार नहीं है; मैं इसे वास्तविक कोड में करने का प्रस्ताव नहीं कर रहा हूं। मैं वास्तव में उत्सुक हूं कि यह वास्तव में करता है।

+2

जहाँ तक मैं देख सकता हूं, आपने स्थिति का सही ढंग से विश्लेषण किया है। आप 'फू' लेने वाले अन्य कार्यों को कॉल कर सकते हैं, और आप पॉलिमॉर्फिक फ़ंक्शंस को कॉल कर सकते हैं, लेकिन आप अप्रत्याशित नाम का उल्लेख करते हुए टाइप हस्ताक्षर नहीं लिख सकते हैं। – kosmikus

उत्तर

3

यह अगर हास्केल अपना खुद का प्रकार जो अनुमान कर Foo रों निर्यात से आप ना करे के लिए गए थे और अधिक दिलचस्प हो सकता है --- इस स्थिति यहां अस्तित्व टाइपिंग जो मॉड्यूल सिस्टम के लिए एक अच्छा विचार है की तरह थोड़ा और व्यवहार करते हैं होगा।

इसके बजाए, प्रकार की जानकारी लीक होती है। तो उदाहरण की जानकारी करता है। "उदाहरण के लिए" निम्नलिखित असुरक्षित

module Foo (foo) where 

    data Foo ... 
    deriving (Data, Typeable) -- for internal use 

    foo :: Foo -> IO() 

foo का उपयोग कर एक "" बुराई उपयोगकर्ता Foo साथ Data.Data.fromConstr ... एकजुट करने के लिए भले ही उन Foo मूल्यों उत्पन्न करने में सक्षम होना चाहिए नहीं कर रहे हैं की अनुमति देगा के बाद से है।

-- mkFoo :: Constr -> Foo  (except I have to let this be inferred) 
mkFoo c = out where 
    out  = fromConstr c 
    ignored = foo out 

आखिरकार, मैं इसे एक गरीब एपीआई मानता हूं। यदि आप उपयोगकर्ता को इसे बनाने की अनुमति दिए बिना किसी प्रकार के उपयोग पर जोर देना चाहते हैं, तो प्रकार निर्यात करें।

संबंधित मुद्दे