D में वोल्डेमॉर्ट प्रकार

यह पोस्ट डी - वोल्डेमॉर्ट प्रकार की एक अनूठी विशेषता के बारे में बात करेगी। प्रकार जिनका उपयोग किया जा सकता है लेकिन नाम नहीं। यह नाम उनके लिए बहुत उपयुक्त नहीं है, लेकिन वाल्टर ब्राइट उन्हें प्यार से बुलाते हैं। Voldemort प्रकार मानक फोबोस लाइब्रेरी में बहुत आम हैं, खासकर std.al एल्गोरिदम और std.array मॉड्यूल में । मास्ट्रिंग डी, स्प्लिटर या जॉइनर से लौटाए गए प्रकार की तलाश में प्रलेखन का अध्ययन करने में घंटों बिता सकते हैं, और वे बिल्कुल वोल्डेमॉर्ट प्रकारों की वापसी करते हैं। इस पोस्ट के बाद, आप सुरक्षित रूप से std.algorithm के स्रोतों को खोल सकते हैं, क्योंकि आप किसी भी You-Know-Who से डरेंगे नहीं।



कभी-कभी, मौजूदा क्षमताओं की बातचीत से अप्रत्याशित आश्चर्य हो सकता है। मुझे लगता है कि हम मूल रूप से डी में वोल्डेमॉर्ट प्रकार निर्धारित करते हैं, लेकिन वास्तव में वे आंद्रेई अलेक्जेंड्रेस्कु द्वारा पाए गए थे। ये Voldermort प्रकार क्या हैं? पर पढ़ें।



सबसे पहले, कुछ पृष्ठभूमि की जानकारी। सामग्री को समझने के लिए, आपको रेंज का विचार होना चाहिए। पहले सन्निकटन में, वे पुनरावृत्तियों के प्रतिस्थापन के रूप में आविष्कार किए गए थे और इसके IEnumerable इंटरफ़ेस के साथ C # दृष्टिकोण के समान हैं। डी में, निम्नलिखित विधियों को लागू करने वाला कोई भी प्रकार एक इनपुटरेंज होगा:

front - get the first element of the range popFront - remove the first element of the range empty - are there more elements in the range? 

ये विधियाँ प्रकार पुनरावृति के लिए आधार प्रदान करती हैं। अब केवल मज़े के लिए, आइए एक InputRange डिज़ाइन करें जो यादृच्छिक संख्याओं के अनंत अनुक्रम को लौटाएगा। (हम ऐसे कार्यों को जनरेटर भी कहते हैं।)

यह इस तरह दिख सकता है (बहुत अच्छा यादृच्छिक संख्या जनरेटर नहीं है, लेकिन यह जल्द ही होगा):

 module rnd; struct RandomNumberGenerator { this(uint seed) { next = seed; popFront(); // get it going } @property int front() { return ((next / 0x10000) * next) >> 16; } void popFront() { next = next * 1103515245 + 12345; } @property bool empty() { return false; } private: uint next; } 

और जो फ़ंक्शन इसे वापस करेगा:

 RandomNumberGenerator generator(uint seed) { return RandomNumberGenerator(seed); } 

और एक महान कार्यक्रम जो इन नंबरों में से 10 को प्रिंट करेगा:

 import std.stdio; import rnd; void main() { int count; foreach (n; generator(5)) { writeln(n); if (++count == 10) break; } } 

यह आमतौर पर सभी है और बंद करो। लेकिन कुछ कष्टप्रद बिंदु हैं। आदर्श रूप से, मुझे केवल rnd.generator फ़ंक्शन के बारे में पता होना चाहिए, लेकिन मॉड्यूल में randomNumberGenerator प्रकार है, जो स्वयं द्वारा मौजूद हो सकता है। यह एन्कैप्सुलेशन उल्लंघन जैसा दिखता है, क्योंकि यह मेरे जनरेटर अमूर्त से बाहर निकलता है।

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

चलिए और भी मज़ेदार बातों पर चलते हैं। सबसे पहले, डी घोषणाओं के लिए प्रकार अनुमान का समर्थन करता है, इसलिए मैं यह लिख सकता हूं:

 auto g = RandomNumberGenerator(seed); 

और g को स्वचालित रूप से RandomNumberGenerator टाइप किया जाएगा। यह एक मानक चीज है। इस धागे को थोड़ा और खींच लिया है, और हम फ़ंक्शन से लौटाए गए प्रकारों को घटा सकते हैं:

 auto square(double d) { return d * d; } auto x = square(2.3); 

और कंपाइलर समझ जाएगा कि स्क्वायर फ़ंक्शन दोगुना वापस आ जाएगा, क्योंकि यह वापसी के बाद अभिव्यक्ति का प्रकार है। और हां, वेरिएबल x भी टाइप डबल होगा। अब हम इस तरह से जनरेटर के लिए हमारे कार्य को फिर से लिखते हैं:

 module rnd; auto generator(uint seed) { struct RandomNumberGenerator { @property int front() { return ((seed / 0x10000) * seed) >> 16; } void popFront() { seed = seed * 1103515245 + 12345; } @property bool empty() { return false; } } RandomNumberGenerator g; g.popFront(); // get it going return g; } 

कुछ मनमोहक हुआ। RandomNumberGenerator एक प्रकार बन गया है जो जनरेटर फ़ंक्शन के दायरे के अंदर है। यह केवल फ़ंक्शन के बाहर दिखाई नहीं देता है। इसके अलावा, इसे नाम नहीं दिया जा सकता है - यह वोल्डेमॉर्ट प्रकार है।

हम केवल इस प्रकार का उदाहरण प्राप्त कर सकते हैं:

 auto g = generator(5); 

और जी का उपयोग करना जारी रखें। मुझे पता है कि आप किस बारे में सोच रहे हैं - टाइपोफ का उपयोग करें और रैंडम नम्बरगैनेर का एक और उदाहरण बनाएं:

 auto g = generator(4); typeof(g) h; 

क्षमा करें, यह काम नहीं करेगा, कंपाइलर अपने दायरे के बाहर वोल्डमॉर्ट प्रकार घोषित करने की अनुमति नहीं देगा (तकनीकी कारण यह है कि स्थानीय बीज चर तक कोई पहुंच नहीं है)।

अब केवल एक ही विवरण है जो मुझे उद्घोष करता है, चक्र:

 int count; foreach (n; generator(5)) { writeln(n); if (++count == 10) break; } 

वह इतने बूढ़े दिखते हैं। सीमाओं के साथ, हम एक मोटी लूप के बिना कर सकते हैं, और इस श्रेणी के पहले 10 तत्वों को लेने के बजाय रेंज रेंज का उपयोग करें:

 void main() { foreach (n; take(generator(5), 10)) writeln(n); } 

और फिर लूप से पूरी तरह छुटकारा पाने के लिए रिटेलन का उपयोग करें:

 void main() { writeln(take(generator(5), 10)); } 

क्या वोल्डेमॉर्ट प्रकार वास्तव में केवल अस्तित्वगत प्रकार हैं?

टाइप T दिया गया है, और U टाइप करें, जिसे T से निकाला जा सकता है और जिसमें T के साथ एक निश्चित संबंध होता है, एक अस्तित्वगत प्रकार है।

उदाहरण के लिए, यदि हमारे पास एक टाइप T है, जो एक पॉइंटर है, तो हम इसके साथ मूल अस्तित्व प्रकार U से घटा सकते हैं:

 import std.stdio; void extractU(T)(T t) { static if (is(TU : U*)) writefln("type %s is a pointer to an %s", typeid(T), typeid(U)); else writefln("type %s is not a pointer", typeid(T)); } void main() { int* t; extractU(t); double d; extractU(d); } 

क्या प्रदर्शित करेगा:

 type int* is a pointer to an int type double is not a pointer 

हालांकि वोल्डेमॉर्ट प्रकार निश्चित रूप से उनके कार्यान्वयन को छिपाते हैं, हालांकि, यह उन्हें अस्तित्वगत प्रकार नहीं बनाता है। चूंकि वोल्डेमॉर्ट प्रकार एक निश्चित प्रकार से प्राप्त नहीं किया जा सकता है, वे अस्तित्वगत नहीं हैं।

निष्कर्ष

वोल्डेमॉर्ट प्रकार डी में एक उल्लेखनीय खोज बन गया, जिसने प्रकारों के एनकैप्सुलेशन की अनुमति दी ताकि उनका उपयोग किया जा सके, लेकिन उन्हें बुलाया नहीं जा सकता।

स्रोत: वाल्टर हाइट वोल्डेमॉर्ट प्रकार डी में