संरचनात्मक टाइप प्रणाली: Difference between revisions

From Vigyanwiki
(Created page with "{{Short description|Class of type systems}} {{refimprove|date=July 2011}} {{type systems}} एक संरचनात्मक प्रकार प्रणाली (य...")
 
No edit summary
Line 3: Line 3:
{{type systems}}
{{type systems}}


एक संरचनात्मक प्रकार प्रणाली (या संपत्ति-आधारित प्रकार प्रणाली) प्रकार प्रणालियों का एक प्रमुख वर्ग है जिसमें प्रकार की संगतता और समानता प्रकार की वास्तविक संरचना या परिभाषा द्वारा निर्धारित की जाती है, न कि अन्य विशेषताओं जैसे कि इसका नाम या घोषणा की जगह। संरचनात्मक प्रणालियों का उपयोग यह निर्धारित करने के लिए किया जाता है कि क्या प्रकार समतुल्य हैं और क्या एक प्रकार दूसरे का उपप्रकार है। यह [[नाममात्र प्रकार की प्रणाली]] के विपरीत है, जहां तुलना प्रकारों के नाम या स्पष्ट घोषणाओं पर आधारित होती है, और [[ बतख टाइपिंग ]], जिसमें रनटाइम पर एक्सेस की गई संरचना का केवल एक हिस्सा संगतता के लिए जांचा जाता है।
'''संरचनात्मक टाइप प्रणाली''' या '''संपत्ति (प्रॉपर्टी) आधारित''' '''डेटा-टाइप प्रणाली,''' डेटाटाइप प्रणालियों का एक प्रमुख वर्ग है जिसमें डेटाटाइप की संगतता और समानता डेटाटाइप की वास्तविक संरचना या परिभाषा द्वारा निर्धारित की जाती है अन्य विशेषताओं जैसे कि इसका नाम या घोषणा की संरचनात्मक प्रणालियों का उपयोग यह निर्धारित करने के लिए किया जाता है कि क्या डेटाटाइप समतुल्य हैं और क्या एक डेटाटाइप दूसरे का उप-डेटाटाइप है। या [[नाममात्र प्रकार की प्रणाली|नॉमिनेटिव डेटाटाइप प्रणाली]] के विपरीत है जहां पर तुलना डेटाटाइप या स्पष्ट घोषणाओं के नाम पर आधारित होती है और [[ बतख टाइपिंग |टाइपिंग]], जिसमें रनटाइम पर अभिगम्य होने वाली संरचना का केवल एक भाग संगतता के लिए नियंत्रित किया जाता है।


== विवरण ==
== विवरण ==
संरचनात्मक टाइपिंग में, एक तत्व को दूसरे के साथ संगत माना जाता है, अगर दूसरे तत्व के प्रकार के भीतर प्रत्येक सुविधा के लिए, पहले तत्व के प्रकार में एक समान और समान विशेषता मौजूद होती है। विवरण पर कुछ भाषाएँ भिन्न हो सकती हैं, जैसे कि सुविधाओं को नाम से मेल खाना चाहिए या नहीं। यह परिभाषा सममित नहीं है, और इसमें उपप्रकार संगतता शामिल है। यदि प्रत्येक दूसरे के साथ संगत है तो दो प्रकारों को समान माना जाता है।
संरचनात्मक टाइपिंग में, एक वेरिएबल को दूसरे के साथ संगत माना जाता है यदि दूसरे वेरिएबल के डेटाटाइप के भीतर प्रत्येक सुविधा के लिए पहले वेरिएबल के डेटाटाइप में एक समान और समान विशेषता सम्मिलित होती है। तब विवरण पर कुछ भाषाएँ भिन्न हो सकती हैं, जैसे कि सुविधाओं को नाम से अनुरूप होना चाहिए या नहीं यह परिभाषा सममित नहीं होती है और इसमें उप-डेटाटाइप संगतता सम्मिलित है। यदि प्रत्येक दूसरे के साथ संगत है तो दो डेटाटाइप को समान माना जाता है।


उदाहरण के लिए, [[OCaml]] ऑब्जेक्ट प्रकारों की अनुकूलता के लिए विधियों पर संरचनात्मक टाइपिंग का उपयोग करता है। [[ जाओ (प्रोग्रामिंग भाषा) ]] एक इंटरफ़ेस के साथ एक प्रकार की संगतता निर्धारित करने के लिए तरीकों पर संरचनात्मक टाइपिंग का उपयोग करता है। C++#Templates|C++ टेम्पलेट फ़ंक्शन प्रकार के तर्कों पर संरचनात्मक टाइपिंग प्रदर्शित करते हैं। [[मिला हुआ]] संरचनात्मक टाइपिंग का उपयोग करता है, लेकिन कक्षाएं संरचनात्मक रूप से उपप्रकारित नहीं होती हैं।
उदाहरण के लिए, [[OCaml|ओसीएएमएल]] ऑब्जेक्ट (वस्तु) डेटाटाइप की अनुकूलता के लिए विधियों पर संरचनात्मक टाइपिंग का उपयोग किया जाता है। [[ जाओ (प्रोग्रामिंग भाषा) |गो (प्रोग्रामिंग भाषा)]] इंटरफ़ेस के साथ एक डेटाटाइप की संगतता निर्धारित करने के तरीकों पर संरचनात्मक टाइपिंग का उपयोग किया जाता है। सी ++ टेम्पलेट फ़ंक्शंस डेटाटाइप तर्कों पर संरचनात्मक टाइपिंग प्रदर्शित करते हैं। जो हैक्स संरचनात्मक टाइपिंग का उपयोग करता है, लेकिन कक्षाएं संरचनात्मक रूप से उप-डेटाटाइप नहीं होती हैं।


[[सबटाइपिंग]] का समर्थन करने वाली भाषाओं में, उपप्रकार संबंध को कैसे परिभाषित किया जाता है, इसके आधार पर एक समान द्विभाजन बनाया जा सकता है। एक प्रकार दूसरे का उपप्रकार है यदि और केवल यदि इसमें आधार प्रकार की सभी विशेषताएं शामिल हैं, या इसके उपप्रकार हैं। उपप्रकार में अतिरिक्त विशेषताएं हो सकती हैं, जैसे सदस्य आधार प्रकार में मौजूद नहीं हैं, या मजबूत अपरिवर्तनीय हैं।
उप-डेटाटाइप बहुरूपता का समर्थन करने वाली भाषाओं में, उप-डेटाटाइप संबंध को कैसे परिभाषित किया जाता है, इसके आधार पर एक समान द्विभाजन बनाया जा सकता है। एक डेटाटाइप दूसरे का उप-डेटाटाइप है यदि इसमें आधार डेटाटाइप की सभी विशेषताएं सम्मिलित हैं या इसके उप-डेटाटाइप हैं। जैसे सदस्य आधार डेटाटाइप या अपरिवर्तनीय डेटाटाइप सम्मिलित नही हैं। उप-डेटाटाइप में अतिरिक्त विशेषताएं हो सकती हैं।


अनुमानित और गैर-अनुमानित बहुरूपता के लिए संरचनात्मक प्रतिस्थापन के बीच एक अंतर मौजूद है। कुछ भाषाएँ, जैसे कि [[हास्केल (प्रोग्रामिंग भाषा)]], उस मामले में संरचनात्मक रूप से स्थानापन्न नहीं करती हैं जहाँ एक अपेक्षित प्रकार घोषित किया जाता है (अर्थात, अनुमानित नहीं), उदाहरण के लिए, केवल उन कार्यों के लिए स्थानापन्न हैं जो प्रकार अनुमान के माध्यम से हस्ताक्षर-आधारित बहुरूपी हैं।<ref>{{cite web|title=हस्ताक्षर आधारित बहुरूपता|url=http://lambda-the-ultimate.org/node/1319#comment-14944}}</ref> तब गलती से एक गैर-अनुमानित प्रकार को उपप्रकार करना संभव नहीं है, हालांकि यह अभी भी एक गैर-अनुमानित प्रकार के लिए एक स्पष्ट रूपांतरण प्रदान करना संभव हो सकता है, जिसे निहित रूप से लागू किया गया है।
अनुमानित और गैर-अनुमानित बहुरूपता के लिए संरचनात्मक प्रतिस्थापन के बीच एक अंतर उपस्थित होता है। कुछ भाषाएँ, जैसे कि [[हास्केल (प्रोग्रामिंग भाषा)]], उस स्थिति में संरचनात्मक रूप से स्थापित नहीं करती हैं जहाँ एक अपेक्षित डेटाटाइप घोषित किया जाता है (अर्थात, अनुमानित नहीं), उदाहरण के लिए, केवल उन कार्यों के लिए स्थापित हैं जो हस्ताक्षर-आधारित बहुरूपी डेटाटाइप के अनुमान के माध्यम से प्रदर्शित होते हैं।<ref>{{cite web|title=हस्ताक्षर आधारित बहुरूपता|url=http://lambda-the-ultimate.org/node/1319#comment-14944}}</ref> तब गलती से एक गैर-अनुमानित डेटाटाइप को उप-डेटाटाइप करना संभव नहीं है, हालांकि यह अभी भी एक गैर-अनुमानित डेटाटाइप के लिए एक स्पष्ट रूपांतरण प्रदान करना संभव हो सकता है, जिसे निहित रूप से प्रयुक्त किया गया है।


स्ट्रक्चरल सबटाइपिंग यकीनन नोमिनेटिव टाइप सिस्टम की तुलना में अधिक लचीला है, क्योंकि यह तदर्थ प्रकार और [[प्रोटोकॉल (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग)]] के निर्माण की अनुमति देता है; विशेष रूप से, यह एक प्रकार के निर्माण की अनुमति देता है जो बाद की परिभाषा को संशोधित किए बिना मौजूदा प्रकार का एक सुपरटेप है। हालाँकि, यह वांछनीय नहीं हो सकता है जहाँ प्रोग्रामर बंद सार बनाना चाहता है।
संरचनात्मक सबटाइपिंग नॉमिनेटिव डेटाटाइप की सबटाइपिंग की तुलना में यकीनन अधिक नम्य है, क्योंकि यह [[प्रोटोकॉल (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग)|प्रोटोकॉल (वस्तु-उन्मुख प्रोग्रामिंग)]] के निर्माण की स्वीकृति देता है विशेष रूप से, यह एक डेटाटाइप के निर्माण की स्वीकृति देता है जो बाद की परिभाषा को संशोधित किए बिना उपस्थित डेटाटाइप का एक उच्च डेटाटाइप है। हालाँकि, यह वांछनीय नहीं हो सकता है जहाँ प्रोग्रामर अमूर्त डेटाटाइप बनाना चाहता है।


संरचनात्मक टाइपिंग बनाम नाममात्र टाइपिंग का एक नुकसान यह है कि दो अलग-अलग परिभाषित प्रकार अलग-अलग उद्देश्यों के लिए अभिप्रेत हैं, लेकिन गलती से एक ही गुण धारण करते हैं (जैसे दोनों पूर्णांक की एक जोड़ी से बना), टाइप सिस्टम द्वारा एक ही प्रकार माना जा सकता है, केवल इसलिए कि वे समान संरचना होना होता है। एक तरह से इससे बचा जा सकता है प्रत्येक उपयोग के लिए एक [[बीजगणितीय डेटा प्रकार]] बनाकर।
'''संरचनात्मक टाइपिंग बनाम नाममात्र टाइपिंग''' का एक नुकसान यह है कि दो अलग-अलग परिभाषित डेटाटाइप अलग-अलग उद्देश्यों के लिए अभिप्रेत हैं, लेकिन गलती से एक ही गुण धारण करते हैं (जैसे दोनों पूर्णांक की एक जोड़ी से बना), डेटाटाइप सिस्टम द्वारा एक ही डेटाटाइप माना जा सकता है, केवल इसलिए कि वे समान संरचना होना होता है। एक तरह से इससे बचा जा सकता है प्रत्येक उपयोग के लिए एक [[बीजगणितीय डेटा प्रकार|बीजगणितीय]] डेटाटाइप बनाकर।
 
1990 में, कुक और अन्य ने साबित किया कि संरचनात्मक रूप से टाइप की गई OO भाषाओं में इनहेरिटेंस सबटाइपिंग नहीं है।<ref>{{cite journal|last1=Cook|first1=W.R.|last2=Hill|first2=W.L.|last3=Canning|first3=P.S.|title=वंशानुक्रम उपप्रकार नहीं है|journal=Proceedings of the Seventeenth Annual ACM Symposium on Principles of Programming Languages|date= January 1990|pages=125–135|doi=10.1145/96709.96721|url=http://dl.acm.org/citation.cfm?id=96721|location=San Francisco, California|isbn=978-0897913430|s2cid=8225906 |doi-access=free}}</ref>
संरचनात्मक टाइपिंग के आधार पर यह जांचना कि दो प्रकार संगत हैं, एक गैर-तुच्छ ऑपरेशन है, उदाहरण के लिए, पिछले चेक किए गए प्रकारों के ढेर को बनाए रखने की आवश्यकता होती है।<ref>{{cite web|title=Type compatibility: name vs structural equivalence|url=https://shape-of-code.com/2018/05/08/type-compatibility-name-vs-structural-equivalence/}}</ref>


1990 में, कुक और अन्य ने साबित किया कि संरचनात्मक रूप से डेटाटाइप की गई OO भाषाओं में इनहेरिटेंस सबटाइपिंग नहीं है।<ref>{{cite journal|last1=Cook|first1=W.R.|last2=Hill|first2=W.L.|last3=Canning|first3=P.S.|title=वंशानुक्रम उपप्रकार नहीं है|journal=Proceedings of the Seventeenth Annual ACM Symposium on Principles of Programming Languages|date= January 1990|pages=125–135|doi=10.1145/96709.96721|url=http://dl.acm.org/citation.cfm?id=96721|location=San Francisco, California|isbn=978-0897913430|s2cid=8225906 |doi-access=free}}</ref>


संरचनात्मक टाइपिंग के आधार पर यह जांचना कि दो डेटाटाइप संगत हैं, एक गैर-तुच्छ ऑपरेशन है, उदाहरण के लिए, पिछले चेक किए गए प्रकारों के ढेर को बनाए रखने की आवश्यकता होती है।<ref>{{cite web|title=Type compatibility: name vs structural equivalence|url=https://shape-of-code.com/2018/05/08/type-compatibility-name-vs-structural-equivalence/}}</ref>
== उदाहरण ==
== उदाहरण ==
OCaml में वस्तुओं को संरचनात्मक रूप से उनके तरीकों के नाम और प्रकार से टाइप किया जाता है।
ओसीएएमएल में वस्तुओं को संरचनात्मक रूप से उनके तरीकों के नाम और डेटाटाइप से प्रदर्शित किया जाता है। वस्तुओं को नाम वर्ग के अतिरिक्त प्रत्यक्ष वस्तुओं से डिजाइन किया जा सकता है। कक्षाएं केवल वस्तुओं को बनाने के कार्यों के रूप में कार्य करती हैं।
 
  # let x =
वस्तुओं को नाममात्र वर्ग के बिना सीधे (तत्काल वस्तुओं) बनाया जा सकता है। कक्षाएं केवल वस्तुओं को बनाने के कार्यों के रूप में कार्य करती हैं।
    object
<वाक्यविन्यास हाइलाइट लैंग = ओकैमल हाइलाइट = 7>
     val mutable x = 5
# चलो एक्स =
    method get_x = x
     वस्तु
    method set_x y = x <- y
      वैल म्यूटेबल एक्स = 5
    end;;
      विधि get_x = x
  val x : < get_x : int; set_x : int -> unit > = <obj>
      विधि set_x y = x <- y
यहाँ ओसीएएमएल पारस्परिक रनटाइम सुविधा के लिए अनुमानित डेटाटाइप की वस्तु को <code>print</code> करता है। इसका डेटाटाइप (<code>< get_x : int; set_x : int -> unit ></code>) केवल इसके तरीकों से परिभाषित किया गया है। दूसरे शब्दों में, x के डेटाटाइप को विधि डेटाटाइप get_x : int और set_x : int -> Unit के अतिरिक्त किसी भी नाम से परिभाषित किया गया है।<ref>{{cite web|title=वस्तु प्रकार|url=http://caml.inria.fr/pub/docs/manual-ocaml/types.html}}</ref> किसी अन्य वस्तुओं को परिभाषित करने के लिए, जिसमें समान विधियाँ और डेटाटाइप के तरीके हैं:
    अंत;;
  # let y =
वैल एक्स: <get_x: int; set_x : int -> Unit > = <obj>
    object
</वाक्यविन्यास हाइलाइट>
     method get_x = 2
यहाँ OCaml इंटरैक्टिव रनटाइम सुविधा के लिए अनुमानित प्रकार की वस्तु को प्रिंट करता है। इसका प्रकार (<code>< get_x : int; set_x : int -> unit ></code>) केवल इसके तरीकों से परिभाषित किया गया है। दूसरे शब्दों में, x के प्रकार को विधि प्रकार get_x : int और set_x : int -> Unit के बजाय किसी भी नाम से परिभाषित किया गया है।<ref>{{cite web|title=वस्तु प्रकार|url=http://caml.inria.fr/pub/docs/manual-ocaml/types.html}}</ref>
    method set_x y = Printf.printf "%d\n" y
किसी अन्य वस्तु को परिभाषित करने के लिए, जिसमें समान विधियाँ और प्रकार के तरीके हैं:
    end;;
<वाक्यविन्यास हाइलाइट लैंग = ओकैमल हाइलाइट = 6>
  val y : < get_x : int; set_x : int -> unit > = <obj>
  # माना y =
ओसीएएमएल उन्हें एक ही डेटाटाइप का स्वीकृति करता है। उदाहरण के लिए, समतुल्य ऑपरेटर केवल एक ही डेटाटाइप के दो मान लेने के लिए डेटाटाइप किया गया है:
     वस्तु
  # x = y;;
      विधि get_x = 2
  - : bool = false
      विधि set_x y = Printf.printf %d\n y
ऐसी स्थिति मे वे एक ही डेटाटाइप के होने चाहिए, अन्यथा यह टाइप-परिवर्तन भी नहीं होगा। इससे यह पता चलता है कि प्रकारों की समानता संरचनात्मक है। और कोई एक फ़ंक्शन को परिभाषित कर सकता है जो एक विधि का आह्वान करता है:
    अंत;;
  # let set_to_10 a = a#set_x 10;;
वैल वाई: <get_x: int; set_x : int -> Unit > = <obj>
  val set_to_10 : < set_x : int -> 'a; .. > -> 'a = <fun>
</वाक्यविन्यास हाइलाइट>
पहले तर्क के लिए अनुमानित डेटाटाइप (<code>< set_x : int -> 'a; .. >)</code> है। <code>..e></code> का अर्थ है कि पहला तर्क कोई भी वस्तु हो सकती है जिसमें एक <code>set_x</code>विधि हो, जो एक <code>int</code> को तर्क के रूप में प्राप्त करती है। तो यह वस्तु पर <code>x</code> के रूप मे प्रयुक्त किया जा सकता है:
OCaml उन्हें एक ही प्रकार का मानता है। उदाहरण के लिए, समानता ऑपरेटर केवल एक ही प्रकार के दो मान लेने के लिए टाइप किया गया है:
  # set_to_10 x;;
<वाक्यविन्यास हाइलाइट लैंग = ओकैमल हाइलाइट = 2>
  - : unit = ()
  # एक्स = वाई ;;
एक अन्य वस्तु बनाई जा सकती है जो उस विधि और विधि डेटाटाइप के लिए होती है अन्य तरीके अप्रासंगिक होते हैं:
- : बूल = असत्य
  # let z =
</वाक्यविन्यास हाइलाइट>
    object
तो वे एक ही प्रकार के होने चाहिए, वरना यह टाइप-चेक भी नहीं होगा। इससे पता चलता है कि प्रकारों की समानता संरचनात्मक है।
     method blahblah = 2.5
 
    method set_x y = Printf.printf "%d\n" y
कोई एक फ़ंक्शन को परिभाषित कर सकता है जो एक विधि का आह्वान करता है:
    end;;
<वाक्यविन्यास हाइलाइट लैंग = ओकैमल हाइलाइट = 2>
  val z : < blahblah : float; set_x : int -> unit > = <obj>
# चलो सेट_to_10 a = a#set_x 10;;
Set_to_10 फ़ंक्शन भी इस पर कार्य करता है:  
वैल set_to_10 : <set_x : int -> 'a; .. > -> 'ए = <मज़ा>
  # set_to_10 z;;
</वाक्यविन्यास हाइलाइट>
  10
पहले तर्क के लिए अनुमानित प्रकार (<code>< set_x : int -> 'a; .. ></code>) दिलचस्प है। <code>..</code> e> का अर्थ है कि पहला तर्क कोई भी वस्तु हो सकती है जिसमें एक set_x विधि हो, जो एक int को तर्क के रूप में लेती है।
  - : unit = ()
 
इससे यह पता चलता है कि विधि आह्वान जैसी वस्तुओ के लिए अनुकूलता संरचना द्वारा निर्धारित की जाती है। माना कि वस्तुओं के लिए केवल एक get_x विधि और कोई अन्य विधि के साथ समानार्थी शब्द को परिभाषित करती है:
तो यह वस्तु पर इस्तेमाल किया जा सकता है <code>x</code>:
  # type simpler_obj = < get_x : int >;;
<वाक्यविन्यास हाइलाइट लैंग = ओकैमल हाइलाइट = 2>
  type simpler_obj = < get_x : int >
  # सेट_to_10 x ;;
जो वस्तु <code>x</code> इस डेटाटाइप का नहीं है लेकिन संरचनात्मक रूप से <code>x</code> इस डेटाटाइप का एक उप डेटाटाइप है, चूंकि <code>x</code> इसके तरीकों का एक उच्च डेटाटाइप सम्मिलित है। इसलिए <code>x</code> इस डेटाटाइप के लिए निर्धारित किया जा सकता है:
- : इकाई = ()
  # (x :> simpler_obj);;
</वाक्यविन्यास हाइलाइट>
  - : simpler_obj = <obj>
 
  # (x :> simpler_obj)#get_x;;
एक अन्य वस्तु बनाई जा सकती है जो उस विधि और विधि प्रकार के लिए होती है; अन्य तरीके अप्रासंगिक हैं:
  - : int = 10
<वाक्यविन्यास हाइलाइट लैंग = ओकैमल हाइलाइट = 6>
लेकिन ऑब्जेक्ट <code>z</code> नहीं, क्योंकि यह एक संरचनात्मक उप डेटाटाइप नहीं है:
# चलो जेड =
  # (z :> simpler_obj);;
     वस्तु
  This expression cannot be coerced to type simpler_obj = < get_x : int >;
      विधि ब्लाहब्लाह = 2.5
  it has type < blahblah : float; set_x : int -> unit > but is here used with type
      विधि set_x y = Printf.printf %d\n y
  < get_x : int; .. >
    अंत;;
  The first object type has no method get_x
वैल जेड: <ब्लाहब्लाह: फ्लोट; set_x : int -> Unit > = <obj>
इससे यह पता चलता है कि सिंटेक्स को विस्तारित करने की अनुकूलता संरचनात्मक होती है।
</वाक्यविन्यास हाइलाइट>
 
Set_to_10 फ़ंक्शन भी इस पर काम करता है:
 
सिंटैक्सहाइलाइट लैंग = ओकैमल>
  # सेट_to_10 z;;
10
- : इकाई = ()
</वाक्यविन्यास हाइलाइट>
इससे पता चलता है कि मेथड इनवोकेशन जैसी चीजों के लिए अनुकूलता संरचना द्वारा निर्धारित की जाती है।
 
आइए वस्तुओं के लिए केवल एक get_x विधि और कोई अन्य विधि के साथ समानार्थी शब्द को परिभाषित करें:
<वाक्यविन्यास हाइलाइट लैंग = ओकैमल हाइलाइट = 2>
  # टाइप simple_obj = <get_x : int >;;
सरल टाइप करें_obj = <get_x: int>
</वाक्यविन्यास हाइलाइट>
 
जो वस्तु <code>x</code> इस प्रकार का नहीं है; लेकिन संरचनात्मक रूप से <code>x</code> इस प्रकार का एक उपप्रकार है, चूंकि <code>x</code> इसके तरीकों का एक सुपरसेट शामिल है। इसलिए <code>x</code> इस प्रकार के लिए मजबूर किया जा सकता है:
<वाक्यविन्यास प्रकाश लैंग = ओकैमल हाइलाइट = 2,4>
  # (एक्स :> simple_obj);;
- : simple_obj = <obj>
# (x :> simple_obj)#get_x;;
- : इंट = 10
</वाक्यविन्यास हाइलाइट>
लेकिन आपत्ति नहीं <code>z</code>, क्योंकि यह एक संरचनात्मक उपप्रकार नहीं है:
 
  # (z :> simple_obj);;
  इस अभिव्यक्ति को simple_obj = <get_x : int >;
  इसका प्रकार है <ब्लाहब्लाह: फ्लोट; set_x : int -> Unit > लेकिन यहाँ प्रकार के साथ प्रयोग किया जाता है
  <get_x: int; .. >
  पहले ऑब्जेक्ट प्रकार की कोई विधि get_x नहीं है
 
इससे पता चलता है कि जबरदस्ती को चौड़ा करने की अनुकूलता संरचनात्मक है।


== संदर्भ ==
== संदर्भ ==

Revision as of 21:38, 9 March 2023

Type systems
General concepts
Major categories
Minor categories

संरचनात्मक टाइप प्रणाली या संपत्ति (प्रॉपर्टी) आधारित डेटा-टाइप प्रणाली, डेटाटाइप प्रणालियों का एक प्रमुख वर्ग है जिसमें डेटाटाइप की संगतता और समानता डेटाटाइप की वास्तविक संरचना या परिभाषा द्वारा निर्धारित की जाती है अन्य विशेषताओं जैसे कि इसका नाम या घोषणा की संरचनात्मक प्रणालियों का उपयोग यह निर्धारित करने के लिए किया जाता है कि क्या डेटाटाइप समतुल्य हैं और क्या एक डेटाटाइप दूसरे का उप-डेटाटाइप है। या नॉमिनेटिव डेटाटाइप प्रणाली के विपरीत है जहां पर तुलना डेटाटाइप या स्पष्ट घोषणाओं के नाम पर आधारित होती है और टाइपिंग, जिसमें रनटाइम पर अभिगम्य होने वाली संरचना का केवल एक भाग संगतता के लिए नियंत्रित किया जाता है।

विवरण

संरचनात्मक टाइपिंग में, एक वेरिएबल को दूसरे के साथ संगत माना जाता है यदि दूसरे वेरिएबल के डेटाटाइप के भीतर प्रत्येक सुविधा के लिए पहले वेरिएबल के डेटाटाइप में एक समान और समान विशेषता सम्मिलित होती है। तब विवरण पर कुछ भाषाएँ भिन्न हो सकती हैं, जैसे कि सुविधाओं को नाम से अनुरूप होना चाहिए या नहीं यह परिभाषा सममित नहीं होती है और इसमें उप-डेटाटाइप संगतता सम्मिलित है। यदि प्रत्येक दूसरे के साथ संगत है तो दो डेटाटाइप को समान माना जाता है।

उदाहरण के लिए, ओसीएएमएल ऑब्जेक्ट (वस्तु) डेटाटाइप की अनुकूलता के लिए विधियों पर संरचनात्मक टाइपिंग का उपयोग किया जाता है। गो (प्रोग्रामिंग भाषा) इंटरफ़ेस के साथ एक डेटाटाइप की संगतता निर्धारित करने के तरीकों पर संरचनात्मक टाइपिंग का उपयोग किया जाता है। सी ++ टेम्पलेट फ़ंक्शंस डेटाटाइप तर्कों पर संरचनात्मक टाइपिंग प्रदर्शित करते हैं। जो हैक्स संरचनात्मक टाइपिंग का उपयोग करता है, लेकिन कक्षाएं संरचनात्मक रूप से उप-डेटाटाइप नहीं होती हैं।

उप-डेटाटाइप बहुरूपता का समर्थन करने वाली भाषाओं में, उप-डेटाटाइप संबंध को कैसे परिभाषित किया जाता है, इसके आधार पर एक समान द्विभाजन बनाया जा सकता है। एक डेटाटाइप दूसरे का उप-डेटाटाइप है यदि इसमें आधार डेटाटाइप की सभी विशेषताएं सम्मिलित हैं या इसके उप-डेटाटाइप हैं। जैसे सदस्य आधार डेटाटाइप या अपरिवर्तनीय डेटाटाइप सम्मिलित नही हैं। उप-डेटाटाइप में अतिरिक्त विशेषताएं हो सकती हैं।

अनुमानित और गैर-अनुमानित बहुरूपता के लिए संरचनात्मक प्रतिस्थापन के बीच एक अंतर उपस्थित होता है। कुछ भाषाएँ, जैसे कि हास्केल (प्रोग्रामिंग भाषा), उस स्थिति में संरचनात्मक रूप से स्थापित नहीं करती हैं जहाँ एक अपेक्षित डेटाटाइप घोषित किया जाता है (अर्थात, अनुमानित नहीं), उदाहरण के लिए, केवल उन कार्यों के लिए स्थापित हैं जो हस्ताक्षर-आधारित बहुरूपी डेटाटाइप के अनुमान के माध्यम से प्रदर्शित होते हैं।[1] तब गलती से एक गैर-अनुमानित डेटाटाइप को उप-डेटाटाइप करना संभव नहीं है, हालांकि यह अभी भी एक गैर-अनुमानित डेटाटाइप के लिए एक स्पष्ट रूपांतरण प्रदान करना संभव हो सकता है, जिसे निहित रूप से प्रयुक्त किया गया है।

संरचनात्मक सबटाइपिंग नॉमिनेटिव डेटाटाइप की सबटाइपिंग की तुलना में यकीनन अधिक नम्य है, क्योंकि यह प्रोटोकॉल (वस्तु-उन्मुख प्रोग्रामिंग) के निर्माण की स्वीकृति देता है विशेष रूप से, यह एक डेटाटाइप के निर्माण की स्वीकृति देता है जो बाद की परिभाषा को संशोधित किए बिना उपस्थित डेटाटाइप का एक उच्च डेटाटाइप है। हालाँकि, यह वांछनीय नहीं हो सकता है जहाँ प्रोग्रामर अमूर्त डेटाटाइप बनाना चाहता है।

संरचनात्मक टाइपिंग बनाम नाममात्र टाइपिंग का एक नुकसान यह है कि दो अलग-अलग परिभाषित डेटाटाइप अलग-अलग उद्देश्यों के लिए अभिप्रेत हैं, लेकिन गलती से एक ही गुण धारण करते हैं (जैसे दोनों पूर्णांक की एक जोड़ी से बना), डेटाटाइप सिस्टम द्वारा एक ही डेटाटाइप माना जा सकता है, केवल इसलिए कि वे समान संरचना होना होता है। एक तरह से इससे बचा जा सकता है प्रत्येक उपयोग के लिए एक बीजगणितीय डेटाटाइप बनाकर।

1990 में, कुक और अन्य ने साबित किया कि संरचनात्मक रूप से डेटाटाइप की गई OO भाषाओं में इनहेरिटेंस सबटाइपिंग नहीं है।[2]

संरचनात्मक टाइपिंग के आधार पर यह जांचना कि दो डेटाटाइप संगत हैं, एक गैर-तुच्छ ऑपरेशन है, उदाहरण के लिए, पिछले चेक किए गए प्रकारों के ढेर को बनाए रखने की आवश्यकता होती है।[3]

उदाहरण

ओसीएएमएल में वस्तुओं को संरचनात्मक रूप से उनके तरीकों के नाम और डेटाटाइप से प्रदर्शित किया जाता है। वस्तुओं को नाम वर्ग के अतिरिक्त प्रत्यक्ष वस्तुओं से डिजाइन किया जा सकता है। कक्षाएं केवल वस्तुओं को बनाने के कार्यों के रूप में कार्य करती हैं। 

 # let x =
   object
    val mutable x = 5
    method get_x = x
    method set_x y = x <- y
   end;;
 val x : < get_x : int; set_x : int -> unit > = <obj>

यहाँ ओसीएएमएल पारस्परिक रनटाइम सुविधा के लिए अनुमानित डेटाटाइप की वस्तु को print करता है। इसका डेटाटाइप (< get_x : int; set_x : int -> unit >) केवल इसके तरीकों से परिभाषित किया गया है। दूसरे शब्दों में, x के डेटाटाइप को विधि डेटाटाइप get_x : int और set_x : int -> Unit के अतिरिक्त किसी भी नाम से परिभाषित किया गया है।[4] किसी अन्य वस्तुओं को परिभाषित करने के लिए, जिसमें समान विधियाँ और डेटाटाइप के तरीके हैं: 

# let y =
   object
    method get_x = 2
    method set_x y = Printf.printf "%d\n" y
   end;;
 val y : < get_x : int; set_x : int -> unit > = <obj>

ओसीएएमएल उन्हें एक ही डेटाटाइप का स्वीकृति करता है। उदाहरण के लिए, समतुल्य ऑपरेटर केवल एक ही डेटाटाइप के दो मान लेने के लिए डेटाटाइप किया गया है: 

# x = y;;
 - : bool = false

ऐसी स्थिति मे वे एक ही डेटाटाइप के होने चाहिए, अन्यथा यह टाइप-परिवर्तन भी नहीं होगा। इससे यह पता चलता है कि प्रकारों की समानता संरचनात्मक है। और कोई एक फ़ंक्शन को परिभाषित कर सकता है जो एक विधि का आह्वान करता है: 

 # let set_to_10 a = a#set_x 10;;
 val set_to_10 : < set_x : int -> 'a; .. > -> 'a = <fun>

पहले तर्क के लिए अनुमानित डेटाटाइप (< set_x : int -> 'a; .. >) है। ..e> का अर्थ है कि पहला तर्क कोई भी वस्तु हो सकती है जिसमें एक set_xविधि हो, जो एक int को तर्क के रूप में प्राप्त करती है। तो यह वस्तु पर x के रूप मे प्रयुक्त किया जा सकता है: 

# set_to_10 x;;
 - : unit = ()

एक अन्य वस्तु बनाई जा सकती है जो उस विधि और विधि डेटाटाइप के लिए होती है अन्य तरीके अप्रासंगिक होते हैं: 

 # let z =
   object
    method blahblah = 2.5
    method set_x y = Printf.printf "%d\n" y
   end;;
 val z : < blahblah : float; set_x : int -> unit > = <obj>

Set_to_10 फ़ंक्शन भी इस पर कार्य करता है: 

# set_to_10 z;;
 10
 - : unit = ()

इससे यह पता चलता है कि विधि आह्वान जैसी वस्तुओ के लिए अनुकूलता संरचना द्वारा निर्धारित की जाती है। माना कि वस्तुओं के लिए केवल एक get_x विधि और कोई अन्य विधि के साथ समानार्थी शब्द को परिभाषित करती है: 

# type simpler_obj = < get_x : int >;;
 type simpler_obj = < get_x : int >

जो वस्तु x इस डेटाटाइप का नहीं है लेकिन संरचनात्मक रूप से x इस डेटाटाइप का एक उप डेटाटाइप है, चूंकि x इसके तरीकों का एक उच्च डेटाटाइप सम्मिलित है। इसलिए x इस डेटाटाइप के लिए निर्धारित किया जा सकता है: 

# (x :> simpler_obj);;
 - : simpler_obj = <obj>
 # (x :> simpler_obj)#get_x;;
 - : int = 10

लेकिन ऑब्जेक्ट z नहीं, क्योंकि यह एक संरचनात्मक उप डेटाटाइप नहीं है: 

# (z :> simpler_obj);;
This expression cannot be coerced to type simpler_obj = < get_x : int >;
it has type < blahblah : float; set_x : int -> unit > but is here used with type
 < get_x : int; .. >
The first object type has no method get_x

इससे यह पता चलता है कि सिंटेक्स को विस्तारित करने की अनुकूलता संरचनात्मक होती है।

संदर्भ

  1. ↑ "हस्ताक्षर आधारित बहुरूपता".
  2. ↑ 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.
  3. ↑ "Type compatibility: name vs structural equivalence".
  4. ↑ "वस्तु प्रकार".


बाहरी संबंध

Retrieved from ‘https://www.vigyanwiki.in/index.php?title=संरचनात्मक_टाइप_प्रणाली&oldid=107376’