F #

में प्रेत प्रकारों को कार्यान्वित करना ओकैम प्रोग्रामर टाइप सिस्टम का उपयोग करके कुछ बाधाओं को लागू करने के लिए तथाकथित 'प्रेत प्रकार' का उपयोग कर सकते हैं। एक अच्छा उदाहरण http://ocaml.janestreet.com/?q=node/11 पर पाया जा सकता है।F #

वाक्यविन्यास type readonly F # में काम नहीं करता है। उपर्युक्त ब्लॉग पोस्ट में चाल को लागू करने के लिए इसे type readonly = ReadOnlyDummyValue के रूप में परिभाषित छद्म-प्रेत प्रकार के साथ प्रतिस्थापित किया जा सकता है।

क्या एफ # में प्रेत प्रकार को परिभाषित करने का एक बेहतर तरीका है?

स्रोत

2010-08-27 Miron Brezuleanu

क्या आपने http://blog.matthewdoig.com/?p=134 और http://blog.matthewdoig.com/?p=138 पढ़ा है? –

लिंक के लिए धन्यवाद। मैं किसी भी तरह से उन्हें याद किया। –

matthewdoig का ब्लॉग मर चुका है, लेकिन लेख archive.org पर हैं: http://web.archive.org/web/20100615031828/http://blog.matthewdoig.com/?p=134 http: //web.archive .org/web/20100615031841/http: //blog.matthewdoig.com/? p = 138 –

मुझे लगता है कि type somename का उपयोग कर परिभाषित प्रकार F # में काम नहीं करेगा। एफ # कंपाइलर को घोषणा से कुछ .NET प्रकार उत्पन्न करने की आवश्यकता है और एफ # विनिर्देश स्पष्ट रूप से परिभाषित नहीं करता है कि प्रेत प्रकारों के लिए क्या होना चाहिए।

आप कार्यान्वयन फ़ाइल (.fs) में एक ठोस प्रकार (उदा। type somename = ReadOnlyDummyValue के साथ) बना सकते हैं और इंटरफ़ेस फ़ाइल (.fsi) में केवल type somename जोड़ कर प्रकार के आंतरिक छिपा सकते हैं। इस तरह आप एक प्रेत प्रकार के करीब आते हैं - फ़ाइल के बाहर उपयोगकर्ता प्रकार के आंतरिक नहीं देख पाएंगे।

एक और आकर्षक विकल्प इंटरफेस का उपयोग करना होगा। यह मेरे लिए तार्किक लगता है, क्योंकि खाली इंटरफ़ेस शायद सबसे सरल प्रकार है जिसे आप घोषित कर सकते हैं (और यह किसी भी डमी पहचानकर्ताओं को पेश नहीं करता है)। खाली इंटरफ़ेस इस तरह दिखता है:

type CanReadWrite = 
    inherit CanRead 
    inherit CanWrite

तो फिर तुम एक समारोह है कि प्रकार Ref<CanRead, int> के मूल्यों ले जा सकते हैं लिख सकते हैं:

type CanRead = interface end 
type CanWrote = interface end

दिलचस्प बात यह है, इस मामले में, यह है कि आप भी विरासत में मिला इंटरफेस बना सकते हैं लेकिन यह भी (क्योंकि ये मान भी पढ़ने का समर्थन) प्रकार Ref<CanReadWrite, int> का महत्व देता है:

let foo (arg:Ref<#CanRead, int>) = // ...

यह कुछ ऐसा है यू हो सकता है की तरह लगता है seful। मैं वास्तव में काफी दिलचस्पी लेता हूं कि यह ओकैम में भी किया जा सकता है (क्योंकि यह इंटरफेस और विरासत के लिए एफ # समर्थन पर निर्भर करता है)।

स्रोत

2010-08-27 21:52:57

इंटरफेस का उपयोग करने का सुझाव बहुत अच्छा है। धन्यवाद! –

@ टॉमस: यह भी ओकैम में भी किया जा सकता है। –

@ जोन: मैं इसकी उम्मीद कर रहा था। मुझे नहीं पता था कि जानकारी का कोई अच्छा स्रोत कैसे और कैसे नहीं मिला। क्या आपके पास कुछ उदाहरण हैं (अधिमानतः स्वतंत्र रूप से उपलब्ध ;-))? –

उत्तर

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