टैग यूनियन

कंप्यूटर विज्ञान में, एक टैग यूनियन, जिसे वेरिएंट, वेरिएंट रिकॉर्ड, च्वाइस टाइप, डिस्क्रिमिनेटेड यूनियन, असंयुक्त संघ , सम टाइप या सहउत्पाद भी कहा जाता है, एक डेटा संरचना है जिसका उपयोग एक मान रखने के लिए किया जाता है जो कई अलग-अलग, लेकिन निश्चित, प्रकार ले सकता है। . किसी भी समय केवल एक ही प्रकार का उपयोग किया जा सकता है, और एक टैग फ़ील्ड स्पष्ट रूप से इंगित करती है कि कौन सा प्रकार उपयोग में है। इसे एक प्रकार के रूप में सोचा जा सकता है जिसमें कई मामले हैं, जिनमें से प्रत्येक को उस प्रकार में हेरफेर होने पर सही ढंग से संभाला जाना चाहिए। यह पुनरावर्ती डेटाटाइप को परिभाषित करने में महत्वपूर्ण है, जिसमें किसी मान के कुछ घटक का प्रकार उस मान के समान हो सकता है, उदाहरण के लिए पेड़ों का प्रतिनिधित्व करने के लिए एक प्रकार को परिभाषित करने में, जहां मल्टी-नोड उपवृक्ष और पत्तियों को अलग करना आवश्यक है। सामान्य यूनियन प्रकार की तरह, टैग किए गए यूनियन प्रत्येक प्रकार के लिए भंडारण क्षेत्रों को ओवरलैप करके भंडारण बचा सकते हैं, क्योंकि एक समय में केवल एक ही उपयोग में होता है।

विवरण

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

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

गणितीय रूप से, टैग किए गए संघ असंयुक्त संघ या विभेदित संघों के अनुरूप होते हैं, जिन्हें आमतौर पर + का उपयोग करके लिखा जाता है। असंयुक्त संघ ए + बी के एक तत्व को देखते हुए, यह निर्धारित करना संभव है कि यह ए या बी से आया है। यदि कोई तत्व दोनों में निहित है, तो ए + बी में मूल्य की दो प्रभावी रूप से अलग प्रतियां होंगी, एक ए से और एक बी से एक.

प्रकार सिद्धांत में, टैग किए गए संघ को योग प्रकार कहा जाता है। योग प्रकार उत्पाद प्रकारों के दोहरे (गणित) हैं। नोटेशन अलग-अलग होते हैं, लेकिन आमतौर पर योग प्रकार होता है $A + B$ दो परिचय प्रपत्र (इंजेक्शन (गणित)) के साथ आता है $inj 1 : A \to A + B$ और $inj 2 : B \to A + B$ . एलिमिनेशन फॉर्म केस विश्लेषण है, जिसे एमएल (प्रोग्रामिंग भाषा) में पैटर्न मिलान के रूप में जाना जाता है|एमएल-शैली भाषाएं: यदि $e$ प्रकार है $A + B$ और $e 1$ और $e 2$ प्रकार है $\tau$ धारणाओं के तहत $x : A$ और $y : B$ क्रमशः, फिर पद ${\mathsf {case}}\ e\ {\mathsf {of}}\ x\Rightarrow e_{1}\mid y\Rightarrow e_{2}$ प्रकार है $\tau$ . योग प्रकार करी-हावर्ड पत्राचार के तहत अंतर्ज्ञानवादी तार्किक विच्छेदन से मेल खाता है।

एक प्रगणित प्रकार को एक विकृत मामले के रूप में देखा जा सकता है: इकाई प्रकारों का एक टैग किया गया संघ। यह अशक्त कंस्ट्रक्टरों के एक सेट से मेल खाता है और इसे एक साधारण टैग वेरिएबल के रूप में कार्यान्वित किया जा सकता है, क्योंकि इसमें टैग के मूल्य के अलावा कोई अतिरिक्त डेटा नहीं है।

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

एक टैग किए गए यूनियन को डेटा क्रमांकन प्रारूपों की सबसे सरल प्रकार की स्व-वर्णन तुलना के रूप में देखा जा सकता है। टैग किए गए यूनियन के टैग को सबसे सरल प्रकार के मेटा डेटा के रूप में देखा जा सकता है।

फायदे और नुकसान

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

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

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

कभी-कभी, अनटैग्ड यूनियनों का उपयोग प्रकारों के बीच बिट-स्तरीय रूपांतरण करने के लिए किया जाता है, जिन्हें C++ में रीइंटरप्रेट कास्ट कहा जाता है। टैग की गई यूनियनें इस उद्देश्य के लिए नहीं हैं; जब भी टैग बदला जाता है तो आम तौर पर एक नया मान निर्दिष्ट किया जाता है।

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

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

{\text{return}}\colon A\to \left(A+E\right)=a\mapsto {\text{value}}\,a

{\text{bind}}\colon \left(A+E\right)\to \left(A\to \left(B+E\right)\right)\to \left(B+E\right)=a\mapsto f\mapsto {\begin{cases}{\text{err}}\,e&{\text{if}}\ a={\text{err}}\,e\\f\,a'&{\text{if}}\ a={\text{value}}\,a'\end{cases}}

जहां मान और त्रुटि यूनियन प्रकार के निर्माता हैं, ए और बी वैध परिणाम प्रकार हैं और ई त्रुटि स्थितियों का प्रकार है। वैकल्पिक रूप से, उसी मोनड को रिटर्न और दो अतिरिक्त कार्यों, एफएमएपी और जॉइन द्वारा वर्णित किया जा सकता है:

{\text{fmap}}\colon (A\to B)\to \left(\left(A+E\right)\to \left(B+E\right)\right)=f\mapsto a\mapsto {\begin{cases}{\text{err}}\,e&{\text{if}}\ a={\text{err}}\,e\\{\text{value}}\,{\text{(}}\,f\,a'\,{\text{)}}&{\text{if}}\ a={\text{value}}\,a'\end{cases}}

{\text{join}}\colon ((A+E)+E)\to (A+E)=a\mapsto {\begin{cases}{\text{err}}\,e&{\mbox{if}}\ a={\text{err}}\,e\\{\text{err}}\,e&{\text{if}}\ a={\text{value}}\,{\text{(err}}\,e\,{\text{)}}\\{\text{value}}\,a'&{\text{if}}\ a={\text{value}}\,{\text{(value}}\,a'\,{\text{)}}\end{cases}}

उदाहरण

मान लें कि हम पूर्णांकों का एक द्विआधारी वृक्ष बनाना चाहते थे। एमएल में, हम इस तरह एक डेटाटाइप बनाकर ऐसा करेंगे:

datatype tree = Leaf
              | Node of (int * tree * tree)

यह दो मामलों के साथ एक टैग किया गया संघ है: एक, पत्ती, का उपयोग पेड़ के पथ को समाप्त करने के लिए किया जाता है, और अनिवार्य भाषाओं में शून्य मान की तरह कार्य करता है। दूसरी शाखा में एक नोड होता है, जिसमें एक पूर्णांक और एक बाएँ और दाएँ उपवृक्ष होता है। लीफ और नोड कंस्ट्रक्टर हैं, जो हमें वास्तव में एक विशेष पेड़ बनाने में सक्षम बनाते हैं, जैसे:

Node(5, Node(1, Leaf, Leaf), Node(3, Leaf, Node(4, Leaf, Leaf)))

जो इस पेड़ से मेल खाता है:

अब हम आसानी से एक टाइपसेफ़ फ़ंक्शन लिख सकते हैं जो, मान लीजिए, पेड़ में नोड्स की संख्या की गणना करता है:

fun countNodes(Leaf) = 0
  | countNodes(Node(int, left, right)) =
      1 + countNodes(left) + countNodes(right)

भाषा समर्थन की समयरेखा

1960

ALGOL 68 में, टैग किए गए यूनियनों को यूनाइटेड मोड कहा जाता है, टैग अंतर्निहित है, और case निर्माण का उपयोग यह निर्धारित करने के लिए किया जाता है कि कौन सा फ़ील्ड टैग किया गया है:

mode node = union (real, int, compl, string); के लिए उपयोग उदाहरण union case का node:

नोड n := 1234 ;

केस एन इन
  (असली आर): प्रिंट(( असली: , आर)),
  (int i): प्रिंट(( int: , i)),
  (compl c): प्रिंट((compli: , c)),
  (स्ट्रिंग एस): प्रिंट(( स्ट्रिंग:, एस))
  प्रिंट आउट(( ?: , n))
esac

1970 और 1980

हालाँकि मुख्य रूप से केवल कार्यात्मक प्रोग्रामिंग भाषाएँ जैसे एमएल (प्रोग्रामिंग भाषा) (1970 के दशक से) और हास्केल (1990 के दशक से) टैग की गई यूनियनों को एक केंद्रीय भूमिका देती हैं और यह जाँचने की शक्ति रखती हैं कि सभी मामलों को संभाला जाता है, अन्य भाषाएँ भी टैग की गई यूनियनों का समर्थन करती हैं। . हालाँकि, व्यवहार में वे कार्यात्मक भाषा कंपाइलरों द्वारा सक्षम अनुकूलन के कारण गैर-कार्यात्मक भाषाओं में कम कुशल हो सकते हैं जो स्पष्ट टैग जांच और प्रकार के क्षरण को समाप्त कर सकते हैं।^{[citation needed]}

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

type shapeKind = (square, rectangle, circle);
     shape = record
                centerx : integer;
                centery : integer;
                case kind : shapeKind of
                   square : (side : integer);
                   rectangle : (width, height : integer);
                   circle : (radius : integer);
	      end;

और यह Ada समकक्ष:

type Shape_Kind is (Square, Rectangle, Circle);
type Shape (Kind : Shape_Kind) is record
   Center_X : Integer;
   Center_Y : Integer;
   case Kind is
      when Square =>
         Side : Integer;
      when Rectangle =>
         Width, Height : Integer;
      when Circle =>
         Radius : Integer;
   end case;
end record;

-- Any attempt to access a member which existence depends
-- on a certain value of the discriminant, while the
-- discriminant is not the expected one, raises an error.

सी (प्रोग्रामिंग भाषा) और सी ++ में, एक सख्त एक्सेस अनुशासन का उपयोग करके अनटैग यूनियनों से एक टैग यूनियन बनाया जा सकता है जहां टैग हमेशा चेक किया जाता है:

enum ShapeKind { Square, Rectangle, Circle };

struct Shape {
    int centerx;
    int centery;
    enum ShapeKind kind;
    union {
        struct { int side; };           /* Square */
        struct { int width, height; }; /* Rectangle */
        struct { int radius; };         /* Circle */
    };
};

int getSquareSide(struct Shape* s) {
    assert(s->kind == Square);
    return s->side;
}

void setSquareSide(struct Shape* s, int side) {
    s->kind = Square;
    s->side = side;
}

/* and so on */

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

C और C++ में एक विशेष टैग किए गए यूनियन के लिए भाषा समर्थन भी है: संभवतः-शून्य पॉइंटर (कंप्यूटर प्रोग्रामिंग)। इसकी तुलना इससे की जा सकती है option एमएल या टाइप करें Maybe हास्केल में टाइप करें, और इसे एक टैग किए नल पॉइंटर के रूप में देखा जा सकता है: दो प्रकार का एक टैग किया गया यूनियन (एक एन्कोडेड टैग के साथ):

मान्य संकेत,
केवल एक मान वाला एक शून्य सूचक प्रकार, null, एक असाधारण स्थिति का संकेत।

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

2000

सी की एक उन्नत बोली जिसे साइक्लोन (प्रोग्रामिंग भाषा) कहा जाता है, में टैग किए गए यूनियनों के लिए व्यापक अंतर्निहित समर्थन है।^[1] रस्ट (प्रोग्रामिंग भाषा), मिला हुआ और स्विफ्ट (प्रोग्रामिंग भाषा) भाषाओं में एनम प्रकार भी टैग किए गए यूनियनों के रूप में काम करते हैं।

C++ लाइब्रेरीज़ को बूस्ट करें ़ की वैरिएंट लाइब्रेरी ने प्रदर्शित किया कि सी++ में लाइब्रेरी के रूप में एक सुरक्षित टैग किए गए यूनियन को कार्यान्वित करना संभव है, जिसे फ़ंक्शन ऑब्जेक्ट का उपयोग करके देखा जा सकता है।

struct display : boost::static_visitor<void>
{
    void operator()(int i)
    {
        std::cout << "It's an int, with value " << i << std::endl;
    }

    void operator()(const std::string& s)
    {
        std::cout << "It's a string, with value " << s << std::endl;
    }
};

boost::variant<int, std::string> v = 42;
boost::apply_visitor(display(), v);

boost::variant<int, std::string> v = "hello world";
boost::apply_visitor(display(), v);

स्काला (प्रोग्रामिंग भाषा) में केस क्लास हैं:

sealed abstract class Tree
case object Leaf extends Tree
case class Node(value: Int, left: Tree, right: Tree) extends Tree

val tree = Node(5, Node(1, Leaf, Leaf), Node(3, Leaf, Node(4, Leaf, Leaf)))

क्योंकि वर्ग पदानुक्रम सील कर दिया गया है, कंपाइलर यह जांच सकता है कि सभी मामलों को एक पैटर्न मिलान में संभाला गया है:

tree match {
  case Node(x, _, _) => println("top level node value: " + x)
  case Leaf          => println("top level node is a leaf")
}

स्काला की केस कक्षाएं भी उपप्रकार के माध्यम से पुन: उपयोग की अनुमति देती हैं:

sealed abstract class Shape(centerX: Int, centerY: Int)
case class Square(side: Int, centerX: Int, centerY: Int) extends Shape(centerX, centerY)
case class Rectangle(length: Int, height: Int, centerX: Int, centerY: Int) extends Shape(centerX, centerY)
case class Circle(radius: Int, centerX: Int, centerY: Int) extends Shape(centerX, centerY)

एफ शार्प (प्रोग्रामिंग भाषा)|एफ# में भेदभावपूर्ण यूनियनें हैं:

type Tree =
  | Leaf
  | Node of value: int * left: Tree * right: Tree

let tree = Node(5, Node(1, Leaf, Leaf), Node(3, Leaf, Node(4, Leaf, Leaf)))

क्योंकि परिभाषित मामले संपूर्ण हैं, कंपाइलर यह जांच सकता है कि सभी मामलों को एक पैटर्न मिलान में संभाला गया है:

match tree with
| Node (x, _, _) -> printfn "top level node value: %i" x
| Leaf           -> printfn "top level node is a leaf"

हेक्स की एनम टैग यूनियनों के रूप में भी काम करती हैं:^[2]

enum Color {
  Red;
  Green;
  Blue;
  Rgb(r:Int, g:Int, b:Int);
}

इन्हें स्विच एक्सप्रेशन का उपयोग करके मिलान किया जा सकता है:

switch (color) {
  case Red: trace("Color was red");
  case Green: trace("Color was green");
  case Blue: trace("Color was blue");
  case Rgb(r, g, b): trace("Color had a red value of " +r);
}

निम (प्रोग्रामिंग भाषा) में ऑब्जेक्ट वेरिएंट हैं^[3] पास्कल और एडा की घोषणा के समान:

type
  ShapeKind = enum
    skSquare, skRectangle, skCircle
  Shape = object
    centerX, centerY: int
    case kind: ShapeKind
    of skSquare:
      side: int
    of skRectangle:
      length, height: int
    of skCircle:
      radius: int

मैक्रो (कंप्यूटर विज्ञान) का उपयोग पैटर्न मिलान का अनुकरण करने या ऑब्जेक्ट वेरिएंट घोषित करने के लिए सिंटैक्टिक शुगर बनाने के लिए किया जा सकता है, जैसा कि यहां पैकेज द्वारा कार्यान्वित किया गया है patty:

import patty

proc `~`[A](a: A): ref A =
  new(result)
  result[] = a

variant List[A]:
  Nil
  Cons(x: A, xs: ref List[A])

proc listHelper[A](xs: seq[A]): List[A] =
  if xs.len == 0: Nil[A]()
  else: Cons(xs[0], ~listHelper(xs[1 .. xs.high]))

proc list[A](xs: varargs[A]): List[A] = listHelper(@xs)

proc sum(xs: List[int]): int = (block:
  match xs:
    Nil: 0
    Cons(y, ys): y + sum(ys[])
)

echo sum(list(1, 2, 3, 4, 5))

2010

स्काला 3 में एनम जोड़े गए हैं,^[4] हमें पहले के स्काला उदाहरणों को अधिक संक्षेप में फिर से लिखने की अनुमति देता है:

enum Tree[+T]:
  case Leaf
  case Node(x: Int, left: Tree[T], right: Tree[T])

enum Shape(centerX: Int, centerY: Int):
  case Square(side: Int, centerX: Int, centerY: Int) extends Shape(centerY, centerX)
  case Rectangle(length: Int, height: Int, centerX: Int, centerY: Int) extends Shape(centerX, centerY)
  case Circle(radius: Int, centerX: Int, centerY: Int) extends Shape(centerX, centerY)

रस्ट (प्रोग्रामिंग भाषा) को टैग किए गए यूनियनों के लिए व्यापक समर्थन प्राप्त है, जिन्हें एनम्स कहा जाता है।^[5] उदाहरण के लिए:

enum Tree {
    Leaf,
    Node(i64, Box<Tree>, Box<Tree>)
}

यह यूनियनों पर मिलान की भी अनुमति देता है:

let tree = Tree::Node(
    2,
    Box::new(Tree::Node(0, Box::new(Tree::Leaf), Box::new(Tree::Leaf))),
    Box::new(Tree::Node(3, Box::new(Tree::Leaf),
        Box::new(Tree::Node(4, Box::new(Tree::Leaf), Box::new(Tree::Leaf)))))
);

fn add_values(tree: Tree) -> i64 {
    match tree {
        Tree::Node(v, a, b) => v + add_values(*a) + add_values(*b),
        Tree::Leaf => 0
    }
}

assert_eq!(add_values(tree), 9);

रस्ट का त्रुटि प्रबंधन मॉडल बड़े पैमाने पर इन टैग किए गए यूनियनों पर निर्भर करता है, विशेषकर Option<T> प्रकार, जो या तो है None या Some(T), और यह Result<T, E> प्रकार, जो या तो है Ok(T) या Err(E).^[6]

स्विफ्ट (प्रोग्रामिंग भाषा) को गणना के माध्यम से टैग किए गए यूनियनों के लिए भी पर्याप्त समर्थन प्राप्त है।^[7] उदाहरण के लिए:

enum Tree {
    case leaf
    indirect case node(Int, Tree, Tree)
}

let tree = Tree.node(
    2,
    .node(0, .leaf, .leaf),
    .node(3, .leaf, .node(4, .leaf, .leaf))
)

func add_values(_ tree: Tree) -> Int {
    switch tree {
    case let .node(v, a, b):
        return v + add_values(a) + add_values(b)

    case .leaf:
        return 0
    }
}

assert(add_values(tree) == 9)

टाइपप्रति से टैग यूनियन बनाना भी संभव है। उदाहरण के लिए:

interface Leaf { kind: "leaf"; }

interface Node { kind: "node"; value: number; left: Tree; right: Tree; }

type Tree = Leaf | Node

const root: Tree = {
  kind: "node",
  value: 5,
  left: {
    kind: "node",
    value: 1,
    left: { kind: "leaf" },
    right: { kind: "leaf" }
  },
  right: {
    kind: "node",
    value: 3,
    left: { kind: "leaf" },
    right: {
      kind: "node",
      value: 4,
      left: { kind: "leaf" },
      right: { kind: "leaf" }
    }
  }
}

function visit(tree: Tree) {
    switch (tree.kind) {
        case "leaf":
            break
        case "node":
            console.log(tree.value)
            visit(tree.left)
            visit(tree.right)
            break 
    } 
}

Python 3.9 टाइपिंग एनोटेशन के लिए समर्थन प्रस्तुत करता है जिसका उपयोग टैग किए गए यूनियन प्रकार (PEP-593) को परिभाषित करने के लिए किया जा सकता है^[8]):

Currency = Annotated[
    TypedDict('Currency', {'dollars': float, 'pounds': float}, total=False),
    TaggedUnion,
]

C++17 ने std::variant और constexpr if<syntaxhighlight lang= c++ > पेश किया है।

ट्री = std::variant<struct Leaf, struct Node> का उपयोग करना;

संरचना पत्ता {

 std::स्ट्रिंग मान;

}; संरचना नोड {

 पेड़* बाएँ = nullptr;
 वृक्ष* दाएँ = nullptr;

};

संरचना ट्रांसवर्सर {

 टेम्प्लेट<नाम टाइप करें टी>
 शून्य ऑपरेटर()(टी&& वी)
 {
   यदि constexpr (std::is_same_v<T, Leaf&>)
   {
     std::cout << v.value << \n ;
   }
   अन्यथा यदि constexpr (std::is_same_v<T, Node&>)
   {
     यदि (v.बाएँ !=nullptr)
       std::visit(Transverser{}, *v.left);

     यदि (v.right !=nullptr)
       std::visit(Transverser{}, *v.right);
   }
   अन्य
   {
     // !sizeof(T) अभिव्यक्ति हमेशा झूठी होती है
     static_assert(!sizeof(T), गैर-संपूर्ण विज़िटर! );
   };
 }

}; /*पेड़ जंगल =...;

 std::विज़िट(ट्रांसवर्सर{}, वन);*/

</सिंटैक्सहाइलाइट>

टैग की गई यूनियनों के रूप में वर्ग पदानुक्रम

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

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

यह भी देखें

विवेचक, कोरबा में विभेदित यूनियनों के लिए प्रकार का टैग
वैरिएंट प्रकार (COM)

संदर्भ

↑ "Cyclone: Tagged Unions".
↑ "एनम्स का उपयोग करना - हेक्स - क्रॉस-प्लेटफ़ॉर्म टूलकिट". Haxe Foundation.
↑ "निम मैनुअल". nim-lang.org. Retrieved 2020-01-23.
↑ "Scala 3 Language Reference: Enumerations". The Scala Team.
↑ "जंग प्रोग्रामिंग भाषा". Mozilla.
↑ "उदाहरण के द्वारा जंग". Mozilla.
↑ "Enumerations — The Swift Programming Language (Swift 5.4)". docs.swift.org. Retrieved 2021-04-28.
↑ "PEP 593 -- Flexible function and variable annotations". Python.org (in English). Retrieved 2021-06-20.

बाहरी संबंध

boost::variant is a C++ typesafe discriminated union
std.variant is an implementation of variant type in D 2.0

[1] "Cyclone: Tagged Unions".

[2] "एनम्स का उपयोग करना - हेक्स - क्रॉस-प्लेटफ़ॉर्म टूलकिट". Haxe Foundation.

[3] "निम मैनुअल". nim-lang.org. Retrieved 2020-01-23.

[4] "Scala 3 Language Reference: Enumerations". The Scala Team.

[5] "जंग प्रोग्रामिंग भाषा". Mozilla.

[6] "उदाहरण के द्वारा जंग". Mozilla.

[7] "Enumerations — The Swift Programming Language (Swift 5.4)". docs.swift.org. Retrieved 2021-04-28.

[8] "PEP 593 -- Flexible function and variable annotations". Python.org (in English). Retrieved 2021-06-20.

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

v t e Data types
Uninterpreted	Bit Byte Trit Tryte Word Bit array
Numeric	Arbitrary-precision or bignum Complex Decimal Fixed point Floating point Reduced precision Minifloat Half precision bfloat16 Single precision Double precision Quadruple precision Octuple precision Extended precision Long double Integer signedness Interval Rational
Pointer	Address physical virtual Reference
Text	Character String null-terminated
Composite	Algebraic data type generalized Array Associative array Class Dependent Equality Inductive Intersection List Object metaobject Option type Product Record or Struct Refinement Set Union tagged
Other	Boolean Bottom type Collection Enumerated type Exception Function type Opaque data type Recursive data type Semaphore Stream Top type Type class Unit type Void
Related topics	Abstract data type Boxing Data structure Generic Kind metaclass Parametric polymorphism Primitive data type Interface Subtyping Type constructor Type conversion Type system Type theory Variable

Anonymous

Search

टैग यूनियन

Namespaces

More

Page actions

Contents

विवरण

फायदे और नुकसान

उदाहरण

भाषा समर्थन की समयरेखा

1960

1970 और 1980

2000

2010

टैग की गई यूनियनों के रूप में वर्ग पदानुक्रम

यह भी देखें

संदर्भ

बाहरी संबंध

Navigation

Navigation

Wiki tools

Wiki tools

Anonymous

Search

टैग यूनियन

विवरण

फायदे और नुकसान

उदाहरण

भाषा समर्थन की समयरेखा

1960

1970 और 1980

2000

2010

टैग की गई यूनियनों के रूप में वर्ग पदानुक्रम

यह भी देखें

संदर्भ

बाहरी संबंध

Navigation

Wiki tools

Page tools

Other projects

Categories