संरचनात्मक टाइप प्रणाली
 | This article needs additional citations for verification. (July 2011) (Learn how and when to remove this template message) |
| Type systems |
|---|
| General concepts |
| Major categories |
|
| Minor categories |
एक संरचनात्मक प्रकार प्रणाली (या संपत्ति-आधारित प्रकार प्रणाली) प्रकार प्रणालियों का एक प्रमुख वर्ग है जिसमें प्रकार की संगतता और समानता प्रकार की वास्तविक संरचना या परिभाषा द्वारा निर्धारित की जाती है, न कि अन्य विशेषताओं जैसे कि इसका नाम या घोषणा की जगह। संरचनात्मक प्रणालियों का उपयोग यह निर्धारित करने के लिए किया जाता है कि क्या प्रकार समतुल्य हैं और क्या एक प्रकार दूसरे का उपप्रकार है। यह नाममात्र प्रकार की प्रणाली के विपरीत है, जहां तुलना प्रकारों के नाम या स्पष्ट घोषणाओं पर आधारित होती है, और बतख टाइपिंग , जिसमें रनटाइम पर एक्सेस की गई संरचना का केवल एक हिस्सा संगतता के लिए जांचा जाता है।
विवरण
संरचनात्मक टाइपिंग में, एक तत्व को दूसरे के साथ संगत माना जाता है, अगर दूसरे तत्व के प्रकार के भीतर प्रत्येक सुविधा के लिए, पहले तत्व के प्रकार में एक समान और समान विशेषता मौजूद होती है। विवरण पर कुछ भाषाएँ भिन्न हो सकती हैं, जैसे कि सुविधाओं को नाम से मेल खाना चाहिए या नहीं। यह परिभाषा सममित नहीं है, और इसमें उपप्रकार संगतता शामिल है। यदि प्रत्येक दूसरे के साथ संगत है तो दो प्रकारों को समान माना जाता है।
उदाहरण के लिए, OCaml ऑब्जेक्ट प्रकारों की अनुकूलता के लिए विधियों पर संरचनात्मक टाइपिंग का उपयोग करता है। जाओ (प्रोग्रामिंग भाषा) एक इंटरफ़ेस के साथ एक प्रकार की संगतता निर्धारित करने के लिए तरीकों पर संरचनात्मक टाइपिंग का उपयोग करता है। C++#Templates|C++ टेम्पलेट फ़ंक्शन प्रकार के तर्कों पर संरचनात्मक टाइपिंग प्रदर्शित करते हैं। मिला हुआ संरचनात्मक टाइपिंग का उपयोग करता है, लेकिन कक्षाएं संरचनात्मक रूप से उपप्रकारित नहीं होती हैं।
सबटाइपिंग का समर्थन करने वाली भाषाओं में, उपप्रकार संबंध को कैसे परिभाषित किया जाता है, इसके आधार पर एक समान द्विभाजन बनाया जा सकता है। एक प्रकार दूसरे का उपप्रकार है यदि और केवल यदि इसमें आधार प्रकार की सभी विशेषताएं शामिल हैं, या इसके उपप्रकार हैं। उपप्रकार में अतिरिक्त विशेषताएं हो सकती हैं, जैसे सदस्य आधार प्रकार में मौजूद नहीं हैं, या मजबूत अपरिवर्तनीय हैं।
अनुमानित और गैर-अनुमानित बहुरूपता के लिए संरचनात्मक प्रतिस्थापन के बीच एक अंतर मौजूद है। कुछ भाषाएँ, जैसे कि हास्केल (प्रोग्रामिंग भाषा), उस मामले में संरचनात्मक रूप से स्थानापन्न नहीं करती हैं जहाँ एक अपेक्षित प्रकार घोषित किया जाता है (अर्थात, अनुमानित नहीं), उदाहरण के लिए, केवल उन कार्यों के लिए स्थानापन्न हैं जो प्रकार अनुमान के माध्यम से हस्ताक्षर-आधारित बहुरूपी हैं।[1] तब गलती से एक गैर-अनुमानित प्रकार को उपप्रकार करना संभव नहीं है, हालांकि यह अभी भी एक गैर-अनुमानित प्रकार के लिए एक स्पष्ट रूपांतरण प्रदान करना संभव हो सकता है, जिसे निहित रूप से लागू किया गया है।
स्ट्रक्चरल सबटाइपिंग यकीनन नोमिनेटिव टाइप सिस्टम की तुलना में अधिक लचीला है, क्योंकि यह तदर्थ प्रकार और प्रोटोकॉल (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग) के निर्माण की अनुमति देता है; विशेष रूप से, यह एक प्रकार के निर्माण की अनुमति देता है जो बाद की परिभाषा को संशोधित किए बिना मौजूदा प्रकार का एक सुपरटेप है। हालाँकि, यह वांछनीय नहीं हो सकता है जहाँ प्रोग्रामर बंद सार बनाना चाहता है।
संरचनात्मक टाइपिंग बनाम नाममात्र टाइपिंग का एक नुकसान यह है कि दो अलग-अलग परिभाषित प्रकार अलग-अलग उद्देश्यों के लिए अभिप्रेत हैं, लेकिन गलती से एक ही गुण धारण करते हैं (जैसे दोनों पूर्णांक की एक जोड़ी से बना), टाइप सिस्टम द्वारा एक ही प्रकार माना जा सकता है, केवल इसलिए कि वे समान संरचना होना होता है। एक तरह से इससे बचा जा सकता है प्रत्येक उपयोग के लिए एक बीजगणितीय डेटा प्रकार बनाकर।
1990 में, कुक और अन्य ने साबित किया कि संरचनात्मक रूप से टाइप की गई OO भाषाओं में इनहेरिटेंस सबटाइपिंग नहीं है।[2] संरचनात्मक टाइपिंग के आधार पर यह जांचना कि दो प्रकार संगत हैं, एक गैर-तुच्छ ऑपरेशन है, उदाहरण के लिए, पिछले चेक किए गए प्रकारों के ढेर को बनाए रखने की आवश्यकता होती है।[3]
उदाहरण
OCaml में वस्तुओं को संरचनात्मक रूप से उनके तरीकों के नाम और प्रकार से टाइप किया जाता है।
वस्तुओं को नाममात्र वर्ग के बिना सीधे (तत्काल वस्तुओं) बनाया जा सकता है। कक्षाएं केवल वस्तुओं को बनाने के कार्यों के रूप में कार्य करती हैं। <वाक्यविन्यास हाइलाइट लैंग = ओकैमल हाइलाइट = 7>
# चलो एक्स =
वस्तु
वैल म्यूटेबल एक्स = 5
विधि get_x = x
विधि set_x y = x <- y
अंत;;
वैल एक्स: <get_x: int; set_x : int -> Unit > = <obj>
</वाक्यविन्यास हाइलाइट>
यहाँ OCaml इंटरैक्टिव रनटाइम सुविधा के लिए अनुमानित प्रकार की वस्तु को प्रिंट करता है। इसका प्रकार (< get_x : int; set_x : int -> unit >) केवल इसके तरीकों से परिभाषित किया गया है। दूसरे शब्दों में, x के प्रकार को विधि प्रकार get_x : int और set_x : int -> Unit के बजाय किसी भी नाम से परिभाषित किया गया है।[4]
किसी अन्य वस्तु को परिभाषित करने के लिए, जिसमें समान विधियाँ और प्रकार के तरीके हैं:
<वाक्यविन्यास हाइलाइट लैंग = ओकैमल हाइलाइट = 6>
# माना y =
वस्तु
विधि get_x = 2
विधि set_x y = Printf.printf %d\n y
अंत;;
वैल वाई: <get_x: int; set_x : int -> Unit > = <obj>
</वाक्यविन्यास हाइलाइट> OCaml उन्हें एक ही प्रकार का मानता है। उदाहरण के लिए, समानता ऑपरेटर केवल एक ही प्रकार के दो मान लेने के लिए टाइप किया गया है: <वाक्यविन्यास हाइलाइट लैंग = ओकैमल हाइलाइट = 2>
# एक्स = वाई ;; - : बूल = असत्य
</वाक्यविन्यास हाइलाइट> तो वे एक ही प्रकार के होने चाहिए, वरना यह टाइप-चेक भी नहीं होगा। इससे पता चलता है कि प्रकारों की समानता संरचनात्मक है।
कोई एक फ़ंक्शन को परिभाषित कर सकता है जो एक विधि का आह्वान करता है: <वाक्यविन्यास हाइलाइट लैंग = ओकैमल हाइलाइट = 2>
# चलो सेट_to_10 a = a#set_x 10;; वैल set_to_10 : <set_x : int -> 'a; .. > -> 'ए = <मज़ा>
</वाक्यविन्यास हाइलाइट>
पहले तर्क के लिए अनुमानित प्रकार (< set_x : int -> 'a; .. >) दिलचस्प है। .. e> का अर्थ है कि पहला तर्क कोई भी वस्तु हो सकती है जिसमें एक set_x विधि हो, जो एक int को तर्क के रूप में लेती है।
तो यह वस्तु पर इस्तेमाल किया जा सकता है x:
<वाक्यविन्यास हाइलाइट लैंग = ओकैमल हाइलाइट = 2>
# सेट_to_10 x ;; - : इकाई = ()
</वाक्यविन्यास हाइलाइट>
एक अन्य वस्तु बनाई जा सकती है जो उस विधि और विधि प्रकार के लिए होती है; अन्य तरीके अप्रासंगिक हैं: <वाक्यविन्यास हाइलाइट लैंग = ओकैमल हाइलाइट = 6>
# चलो जेड =
वस्तु
विधि ब्लाहब्लाह = 2.5
विधि set_x y = Printf.printf %d\n y
अंत;;
वैल जेड: <ब्लाहब्लाह: फ्लोट; set_x : int -> Unit > = <obj>
</वाक्यविन्यास हाइलाइट>
Set_to_10 फ़ंक्शन भी इस पर काम करता है:
सिंटैक्सहाइलाइट लैंग = ओकैमल>
# सेट_to_10 z;; 10 - : इकाई = ()
</वाक्यविन्यास हाइलाइट> इससे पता चलता है कि मेथड इनवोकेशन जैसी चीजों के लिए अनुकूलता संरचना द्वारा निर्धारित की जाती है।
आइए वस्तुओं के लिए केवल एक get_x विधि और कोई अन्य विधि के साथ समानार्थी शब्द को परिभाषित करें: <वाक्यविन्यास हाइलाइट लैंग = ओकैमल हाइलाइट = 2>
# टाइप simple_obj = <get_x : int >;; सरल टाइप करें_obj = <get_x: int>
</वाक्यविन्यास हाइलाइट>
जो वस्तु x इस प्रकार का नहीं है; लेकिन संरचनात्मक रूप से x इस प्रकार का एक उपप्रकार है, चूंकि x इसके तरीकों का एक सुपरसेट शामिल है। इसलिए x इस प्रकार के लिए मजबूर किया जा सकता है:
<वाक्यविन्यास प्रकाश लैंग = ओकैमल हाइलाइट = 2,4>
# (एक्स :> simple_obj);; - : simple_obj = <obj> # (x :> simple_obj)#get_x;; - : इंट = 10
</वाक्यविन्यास हाइलाइट>
लेकिन आपत्ति नहीं z, क्योंकि यह एक संरचनात्मक उपप्रकार नहीं है:
# (z :> simple_obj);; इस अभिव्यक्ति को simple_obj = <get_x : int >; इसका प्रकार है <ब्लाहब्लाह: फ्लोट; set_x : int -> Unit > लेकिन यहाँ प्रकार के साथ प्रयोग किया जाता है <get_x: int; .. > पहले ऑब्जेक्ट प्रकार की कोई विधि get_x नहीं है
इससे पता चलता है कि जबरदस्ती को चौड़ा करने की अनुकूलता संरचनात्मक है।
संदर्भ
- ↑ "हस्ताक्षर आधारित बहुरूपता".
- ↑ Cook, W.R.; Hill, W.L.; Canning, P.S. (January 1990). "वंशानुक्रम उपप्रकार नहीं है". Proceedings of the Seventeenth Annual ACM Symposium on Principles of Programming Languages. San Francisco, California: 125–135. doi:10.1145/96709.96721. ISBN 978-0897913430. S2CID 8225906.
- ↑ "Type compatibility: name vs structural equivalence".
- ↑ "वस्तु प्रकार".
- Pierce, Benjamin C. (2002). "19.3". Types and Programming Languages. MIT Press. ISBN 978-0-262-16209-8.
