👳 ⛲️ 🥔 डी 2 भाषा और मेटाप्रोग्रामिंग: वाइडर और वीडर 🤶 ⚽️ 🏒

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

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

लक्ष्य टिप्पणियों और कम शब्दों के साथ अधिक दृश्य कोड उदाहरण हैं।

आत्मनिरीक्षण उपकरण

अभिव्यक्ति है

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

void main() { //     assert( !is(garbage[id]) ); assert( !is(x) ); alias int x; assert( is(x) ); //     assert( is(x : long) ); assert( !is( x : string ) ); //     assert( is( x == int) ); assert( !is( x == long) ); //    + pattern matching + alias declaration alias long[char[]] AA; static if( is( AA T : T[U], U : const char[]) ) alias T key; else alias void key; assert( is(key == long) ); }

अंतिम उदाहरण विशेष रूप से दिलचस्प है - एक साथ उपयोग किया जाता है

एक सहकार कंटेनर में कास्ट रोर [] की जांच प्रकार
एक कंटेनर प्रकार से पैटर्न के द्वारा एक प्रमुख प्रकार का चयन करने के लिए
नेस्टेड स्कोप के लिए उपनाम बनाएं

हालाँकि, बहुत अधिक बार जो आप देखते हैं वह है (टाइपोफ़ (...)) के संदर्भ में। टाइपोफ की बात:

टाइपोफ़ अभिव्यक्ति

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

 int func(); void main() { //  ,     alias typeof(func()) ret_type; assert( is( ret_type == int ) ); double func_prim() { //  ,       assert( is( typeof(return) == double ) ); return 0; } //    is   constraint "      <" void template_func(T)( T t ) if ( is(typeof( T.init < T.init )) ) { } template_func(20); // struct S {} // template_func(S.init); // error }

लक्षण / std.traits

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

 abstract class C { } class B { int a; } void main() { assert( __traits(isAbstractClass, C ) ); assert(! __traits(isAbstractClass, B ) ); assert(! __traits(isAbstractClass, int ) ); assert( __traits(hasMember, B, "a") ); assert( !__traits(hasMember, C, "a") ); // offtopic:      [ ] - allMembers   ,         auto a = [ __traits(allMembers, B) ]; assert( a == ["a", "toString", "toHash", "opCmp", "opEquals", "Monitor", "factory"] ); }

std.traits - समान उद्देश्यों के लिए एक मानक पुस्तकालय मॉड्यूल, जो पहले उल्लेख किए गए टूल का उपयोग करके लिखा गया है। कुछ उपयोगिता कार्य बहुत दिलचस्प हैं, उदाहरण के लिए, mangledName:

 import std.traits; import std.stdio; void func1(); extern ( C ) void func2(); void main() { // _D9stdtraits5func1FZv writeln( mangledName!(func1) ); // func2 writeln( mangledName!(func2) ); }

टाइप करें

D2 मान और प्रकार दोनों के tuples बना सकता है, लेकिन हम निश्चित रूप से, बाद में मुख्य रूप से रुचि रखते हैं। कारण है कि मैं टटोलने का उपकरण के संदर्भ में टुपल्स का उल्लेख संकलक से विशेष समर्थन है, आप आगे संकलन के लिए एक ही std.traits का उपयोग कर प्राप्त tuples का उपयोग करने की अनुमति देता है।

 import std.typetuple; import std.traits; import std.stdio; //     void func1( int, double, string ) { } //      " " alias TypeTuple!( int, double, string ) tp_same; // ,     ,   func1! void func2( tp_same tp ) { assert( is( typeof(tp[0]) == int ) ); assert( is( typeof(tp[1]) == double ) ); assert( is( typeof(tp[2]) == string ) ); } //    ,     ? alias ParameterTypeTuple!(func1) tp_func1_copy; // ...      . void func3( tp_func1_copy tp ) { foreach( i; tp) { writeln(typeid( typeof(i) ), " ", i); } // : // int 2 // double 2 // immutable(char)[] 2 } void main() { //        func1( 2, 2.0, "2"); func2( 2, 2.0, "2"); func3( 2, 2.0, "2"); // ! assert( is( typeof(func1) == typeof(func2) ) ); assert( is( typeof(func2) == typeof(func3) ) ); }

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

सीटीईई अनलेडेड

CTFE (कम्पाइल-टाइम फील्ड इवैल्यूएशन) एक ऐसा विषय है जो संक्षेप में और अपार वर्णन करने के लिए बहुत सरल है यदि आप सभी बारीकियों पर विचार करने का प्रयास करते हैं। तथ्य यह है कि कुछ कार्यों / अभिव्यक्तियों को संकलन समय पर गणना की जा सकती है, एक नई अवधारणा नहीं है और समान C ++ प्रोग्रामर के लिए काफी परिचित है। क्या असामान्य है कि कैसे छोटे D2 CTFE कार्यों को प्रतिबंधित करता है। यहाँ आधिकारिक प्रलेखन से एक विवरण है:

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

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

 import std.math; enum PrecomputedSqrtIndex { Min = 1, Max = 10 } // pure, nothrow  in , ,  ,         :) pure nothrow double[int] precompute_sqrt_lookup( in int from, in int to ) { double[int] result; foreach( i; from..to+1 ) result[i] = sqrt(i); return result; } enum sqrt_lookup = precompute_sqrt_lookup( PrecomputedSqrtIndex.Min, PrecomputedSqrtIndex.Max ); void main() { }

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

लेकिन रियल मेटाप्रोग्रामिंग के संदर्भ में CTFE का क्या? मैं आपको मिक्सिन से मिलाने के बाद उनके पास लौटूंगा।

Mixin

टेम्पलेट मिश्रण

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

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

यहाँ कोड का एक लंबा टुकड़ा है, जो पहले से ही वास्तविक परियोजना में लिखा जा सकता है के समान है:

 import std.range : isForwardRange; import std.stdio : writeln; import std.typecons : Tuple; // "" mixin,      mixin template AddForwardRangeMethods( alias data_container, alias order_container ) // ,      data_container if ( is(typeof( data_container.length ) : int ) && // ...  order_container     data_container is(typeof( data_container[ order_container[0] ] )) //    - ,     - :) ) { // ..             ,  //         . private struct Result { //       private int last_index; //    -   ,    //     typeof(data_container) ref_data; typeof(order_container) ref_order; alias typeof(order_container[0]) Key_t; static if ( is( typeof(data_container) T : T[U], U : Key_t ) ) { alias T Value_t; } else static assert(0, "Wrong data_container / order_container data_container types" ); this(typeof(data_container) data, typeof(order_container) order) { last_index = 0; ref_data = data; ref_order = order; } //  ,  forward range bool empty() { return last_index >= ref_data.length; } Tuple!(Key_t, Value_t) popFront() { //    scope   , ,  //        scope (exit) last_index++; return front(); } Tuple!(Key_t, Value_t) front() { return typeof(return)( ref_order[last_index], ref_data[ref_order[last_index]] ); } Result save() { return Result( ref_data, ref_order ); } } public Result fwdRange() { return Result( data_container, order_container ); } } //  ,  mixin class A { private int[int] a; private int[] order; this() { a = [ 2 : 4, 4 : 16, 3 : 9 ]; order = [ 2, 4, 3 ]; } //   ! mixin AddForwardRangeMethods!(a, order); } void main() { //    -    forward range,  duck typing assert(isForwardRange!(A.Result)); auto a = new A(); auto r = a.fwdRange; foreach( i; r ) writeln( i ); // Tuple!(int,int)(2, 4) // Tuple!(int,int)(4, 16) // Tuple!(int,int)(3, 9) }

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

स्ट्रिंग मिश्रण

और अंत में, हमें D2 मेटाप्रोग्रामिंग की सबसे शक्तिशाली और अस्पष्ट विशेषताओं में से एक मिला। इस क्षेत्र में प्रवेश करने पर, आप टाइप सिस्टम द्वारा प्रदान किए गए अधिकांश सुविधाजनक त्रुटि संदेश खो देते हैं, और आपको सी मैक्रोज़ के नरक के करीब एक कदम मिलता है - लेकिन आपकी संभावनाएं लगभग असीम हो जाती हैं।
स्ट्रिंग मिक्सिंग कुछ मायनों में स्क्रिप्टिंग भाषाओं से निकाले जाने के समान है, इसका सिंटैक्स बहुत सरल है:

 mixin("some string here")

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

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

एक पहले से ही उग आए हुए लेख को अव्यवस्थित करने के लिए नहीं, उदाहरण के लिए, मैं एक निश्चित डैनियल की एक मजेदार ट्रिक का लिंक प्रदान करूंगा: www.prowiki.org/wiki4d/wiki.cgi?Danielneep/shfmt
यदि ऐसा करने के लिए डैनियल PHP की शैली में संभव हो तो:

 int a = 3; writeln("a = $a");

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

एक उपसंहार के बजाय

प्रारंभ में, मैं प्रत्येक अवसर पर बहुत अधिक ध्यान केंद्रित करना चाहता था और आवेदन के विभिन्न सफल और अवांछनीय तरीकों को बाहर करना चाहता था। लेकिन जैसा कि आपने लिखा है, यह पता चला है कि लेख का आकार कोड के उदाहरणों के साथ इतने समृद्ध स्वाद के लिए अश्लील गति से बढ़ रहा है। अंत में, मैंने सिर्फ उपकरण के पूरे सेट का व्यापक संभव विचार देने की कोशिश की, जो डी 2 मेटाप्रोग्रामिंग के लिए प्रदान करता है। यदि कम से कम एक बार आपने सोचा कि "वाह, लेकिन इसकी मदद से आप मेरे सपनों की <a फीचर को बना सकते हैं।", तो लक्ष्य पूरा हो गया।

अक्सर D2 के लिए आने वाले नए लोगों को संकलन के चरण में कुछ करने के अवसरों की प्रचुरता से खो जाते हैं और इन क्षमताओं के लिए उचित मात्रा में अनुशासन की आवश्यकता होती है और अपने कोड को गड़बड़ाने की नहीं। इसलिए वास्तु प्रलोभनों में संयम रखने की कोशिश करें। बोन एपीटिट :)

टाइपोस और शैलीगत गलतियों के बारे में कृपया निजी में सूचित करें।

सभी उदाहरणों का परीक्षण dmd संस्करण 2.057 पर किया गया था

डी 2 भाषा और मेटाप्रोग्रामिंग: वाइडर और वीडर