डी प्रोग्रामिंग भाषा - जारी रखी

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


मैं शुरू करूँगा, शायद, सभी सामान्य चीजों के साथ - सामान्यीकृत प्रोग्रामिंग (जेनरिक, टेम्प्लेट)। यही है, C ++ टेम्प्लेट में हम सभी से परिचित हैं।

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

 T[] MapInc(T)(T[] arr) { auto res = new T[arr.length]; foreach(i, v; arr) res[i] = v + 1; return res; } 

सबसे पहले, मैं ध्यान देता हूं कि रिटर्न का परिणाम भी मानकीकृत है। बहुत आरामदायक संपत्ति।
आइए देखें कि यह कैसे काम करता है:

 void main() { auto ar = [1,2,3,4]; auto ard = [1.0,2.0,3.0,4.0]; assert(MapInc(ar) == [2,3,4,5], "wrong!"); assert(MapInc(ard) == [2.0,3.0,4.0,5.0], "wrong!"); } 

सभी परीक्षण अपेक्षित रूप से पास हुए! निश्चित, सफलता। लेकिन रुकिए ... आइए कोशिश करते हैं यह कोड:

 auto ar = ["1","2","3","4"]; MapInc(ar); 

संकलित नहीं? कोई आश्चर्य नहीं। लाइन पर संकलन त्रुटि

 res[i] = v + 1; 

और, परिणामस्वरूप, लाइन पर

 MapInc(ar); 

अब कल्पना करें कि यह फ़ंक्शन हमारे द्वारा नहीं लिखा गया था, लेकिन लाइब्रेरी में गहरे दफन किया गया था। यह सही है?
हालांकि, गलतफहमी को हल करने के लिए डी बहुत सुविधाजनक तरीका प्रदान करता है। चूंकि कोड की एक पंक्ति एक हजार शब्दों को बदल देगी, बस एक नज़र डालें:

 T[] MapInc(T)(T[] arr) if(is(typeof(arr[0] + 1) == typeof(arr[0]))) //   . { auto res = new T[arr.length]; foreach(i, v; arr) res[i] = v + 1; return res; } 

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

 if(is(typeof(arr[0] + 1) == typeof(arr[0]))) 

आपको शायद लगता है कि यह पूरी तरह से शर्मिंदगी है। संकलन चरण पर गिरफ्तारी [0] और यहां तक ​​कि + 1 की गणना कैसे करें? सही उत्तर कुछ नहीं है। संकलक इस मान की गणना नहीं करता है। इस स्थिति में, टाइपोफ़ स्वयं के तर्क का मूल्यांकन नहीं करता है, यह केवल उस प्रकार के मूल्य को संक्रमित करता है जो इसे एक तर्क के रूप में पारित किया जाता है।
इस तरह से

 typeof(arr[0] + 1) == typeof(arr[0]) 

केवल इसका मतलब है कि:
a) हम टाइपोफ (1) मान जोड़ सकते हैं टाइपोफ (गिरफ्तार [0]) प्रकार मान और
बी) जोड़ने के बाद, हम फिर से टाइप टाइप (गिरफ्तारी [0]) प्राप्त करते हैं।
महान, है ना?

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

 T[] MapInc(T)(T[] arr, T b) if(is(typeof(arr[0] + b) == typeof(arr[0]))) { auto res = new T[arr.length]; foreach(i, v; arr) res[i] = v + b; return res; } 

अब हम एक नहीं, बल्कि एक मनमानी संख्या जोड़ रहे हैं। हमारे समारोह की जाँच करें:

 void main() { auto ar = [1,2,3,4]; assert(MapInc(ar,3) == [4,5,6,7], "wrong!"); } 
 

void main() { auto ar = [1,2,3,4]; assert(MapInc(ar,3) == [4,5,6,7], "wrong!"); }

सफलता! लेकिन रुकिए, हमने उसके साथ बहुत धीरज से पेश आया, कुछ हद तक काम को जटिल बनाने की कोशिश की:

 void main() { auto ar = [1.0,2.0,3.0,4.0]; assert(MapInc(ar,1) == [2.0,3.0,4.0,5.0], "wrong!"); // ,  . } 

ऊप्स! संकलक हमारे रमणीय डिजाइन को नहीं समझ सके। यह क्या है: एक और क्रोधी सख्त प्रकार की प्रणाली हमें नुकसान की कामना करती है? लेकिन चलो एक करीब देखो: हम खुद को दोषी मानते हैं! परिभाषा स्पष्ट रूप से बताती है कि सरणी और संख्या एक ही प्रकार की हैं। सब ठीक है। आइए विभिन्न प्रकार के मूल्यों को स्वीकार करने के लिए उदाहरण को संशोधित करने का प्रयास करें।

 T[] MapInc(T,P)(T[] arr, P b) if(is(typeof(arr[0] + b) == T)) { auto res = new T[arr.length]; foreach(i, v; arr) res[i] = v + b; return res; } 

अब अंतिम सफलता अब है:

 void main() { auto ar = [1.0,2.0,3.0,4.0]; assert(MapInc(ar,1) == [2.0,3.0,4.0,5.0], "wrong!"); // , ! } 

मैं यह भी ध्यान देता हूं कि फ़ंक्शन हेडर में स्थिति को बदलना नहीं था - हम पिछले संस्करण के समान ही चाहते हैं।

अब कठोरता के प्रेमियों के लिए स्पष्टीकरण का समय है। फ़ंक्शन कॉल रिकॉर्ड करने के लिए ऐसा विकल्प:

 MapInc(ar,1); 

बस स्वचालित प्रकार के निष्कर्ष का परिणाम है। और यहाँ है कि चीजें वास्तव में कैसी हैं:

डी में, प्रत्येक फ़ंक्शन में तर्क के दो सेट होते हैं और सामान्य रूप से परिभाषित किया जाता है

 T f(c1,c2/*, others*/)(r1,r2/*, others*/); 

पहला सेट संकलन समय तर्क सेट है, दूसरा रन टाइम तर्क है।
नाम खुद के लिए बोलता है: पहले सेट से तर्क संकलन समय पर, दूसरे सेट से, रन टाइम पर गणना की जाती है। और हमेशा ऐसा नहीं होता है।
इस प्रकार, संकलन समय के सभी तर्क हमें फिर से "मुफ्त में" दिए जाते हैं, लेकिन फिर से हम उन मूल्यों का उपयोग नहीं कर सकते हैं जो संकलन के दौरान गणना योग्य नहीं हैं।

बहुरूपिक कार्यों को कॉल करने के लिए, सिंटैक्स निम्नानुसार है:

 auto v = f!(c1,c2/*, others*/)(r1,r2/*, others*/); 

उसी समय, यदि संकलन समय तर्क केवल एक है, तो आप कोष्ठक को छोड़ सकते हैं:

 auto v = f!c1(r1,r2/*, others*/); 

संकलन के समय के तर्क न केवल प्रकार के हो सकते हैं, बल्कि सामान्य तौर पर संकलन चरण में किसी भी अभिव्यक्ति की गणना की जाती है। उदाहरण के लिए, "42"।
लेकिन 42 सी + + टेम्पलेट्स में फिट होगा, यहां सब कुछ बहुत दिलचस्प है: यहां तक ​​कि कार्यों को ऐसे मापदंडों के रूप में इस्तेमाल किया जा सकता है! एक उदाहरण पर विचार करें:

 P[] Map(alias f,T,P)(T[] arr) if(is(typeof(f(arr[0])) == P)) { auto res = new P[arr.length]; foreach(i, v; arr) res[i] = f(v); return res; } void main() { auto ard = [1.0,2.0,3.0,4.0]; auto ar = [1,2,3,4]; assert(Map!((double x) {return x+1;},double,double)(ard) == [2.0,3.0,4.0,5.0], "wrong!"); assert(Map!((int x) {return x+1.0;},int,double)(ar) == [2.0,3.0,4.0,5.0], "wrong!"); assert(Map!((int x) {return x+1;},int,int)(ar) == [2,3,4,5], "wrong!"); assert(Map!((double x) {return x+1.0;},int,double)(ar) == [2.0,3.0,4.0,5.0], "wrong!"); } 

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

उदाहरण के रूप में प्रसिद्ध सॉर्ट एल्गोरिथ्म का उपयोग करके C ++ 11 STL दृष्टिकोण के साथ इस दृष्टिकोण की तुलना करें।

 auto arr = {1,2,3,4}; sort(arr.begin(), arr.end(), [&](int a, int b) {return a > b && a < 42;}); 

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

लेख पहले ही पोस्ट किया जा चुका है, लेकिन मैंने अभी शुरुआत की है!

तो, संकलन प्रक्रिया में गणनाओं के साथ जारी रखें।

हम सभी को याद है, लेकिन अनुचित और पाप, जैसे भावों के साथ

 #ifdef P ... #else ... #endif 

डी में कोई प्रीप्रोसेसर नहीं है (कोई कहेगा: "भगवान का शुक्र है," कोई व्यक्ति घुरघुर करेगा, लेकिन हम होलीवर की व्यवस्था नहीं करेंगे, लेकिन पढ़ना जारी रखेंगे)।
हालांकि, भाषा में ऐसे निर्माण हैं जो इसे प्रतिस्थापित करते हैं। उदाहरण के लिए, उपर्युक्त निर्माण स्टेटिक को स्टेटमेंट में बदल देगा। सामान्य तौर पर, हमने उसके साथ बहुत व्यवहार किया (मेरा विश्वास करो, ठीक है, सोओउओ) गलत तरीके से: स्थिर यदि बहुत कुछ कर सकता है।
यहां आपको एक विषयांतर चाहिए। D का कीवर्ड उपनाम है। यह बहुत काम करता है, लेकिन अब हमें इसे एक टाइफाइड की जरूरत है। यहाँ एक उदाहरण है:

 alias int MyOwnPersonalInt; 

इतना स्थिर अगर। मैं अभ्यास में दिखाने की कोशिश करूंगा:

 enum Arch {x86, x64}; static Arch arch = x86; static if(arch == x86) alias int integer; else alias long integer; 

हमने एक पूर्णांक प्रकार को परिभाषित किया, जिसका आकार उस मशीन की वास्तुकला पर निर्भर करता है जिस पर कोड संकलित किया गया है।
अब हम इसे किसी अन्य प्रकार की तरह उपयोग कर सकते हैं:

 integer Inc(integer n) {return n+2;} 

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

और निष्कर्ष में, एक और दिलचस्प और उपयोगी विशेषता। भाषा की विचारधारा के सिद्धांतों में से एक है: संकलित समय पर गणना करें वह सब कुछ जिसकी गणना की जा सकती है।
निम्नलिखित कोड पर विचार करें:

 static int a = f(); //   enum int b = f(); 

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

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

मुझे उम्मीद है कि मैंने अपना काम अच्छी तरह से किया और यह लेख लोगों को प्रोग्रामिंग भाषा डी में रुचि लेने में सक्षम होगा।
जो लोग यहां तक ​​पढ़ सकते हैं - मुझे आशा है कि आपने इसका आनंद लिया और आपके ध्यान के लिए धन्यवाद!

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