एक प्रोग्रामिंग भाषा में स्टैटिक्स: प्रकारों को छोड़कर क्या?

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

लेकिन मामला केवल डेटा प्रकारों तक ही सीमित क्यों है? आइए थोड़ा कल्पना करने की कोशिश करें कि कंपाइलर और क्या कर सकता है।

मान लीजिए कि हमारे पास कुछ दिनों के लिए एक निरंतरता है:

const int secondsPerDay = 24*60*60; 

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

हम विज्ञान कथा (विषय क्षेत्र और C ++ में दोनों) के क्षेत्र में आगे बढ़ते हैं।

हमने मंगल के निवासियों के लिए स्थानीयकृत हमारे कार्यक्रम का एक संस्करण जारी करने का निर्णय लिया:

 enum Planet{ Earth, Mars } const Planet locale = Mars; int secondsPerDay() { if(locale == Earth) { return 24*60*60; } if(locale == Mars) { return 24*60*60+37*60+23; } assert(false, "unknown locale"); } 

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

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

एक दिलचस्प उदाहरण पर विचार करें। हम एक फ़ंक्शन लिखेंगे जो संरचना प्रकार और उसके क्षेत्रों के नाम के आधार पर एक SQL क्वेरी उत्पन्न करेगा:

 //  -  ,      //    -   T fetchById<T>(Connection conn, int id){ //  !!! assert(is_struct(T), name_of(T)+" is not struct"); assert(has_field(T, id), name_of(T)+ " doesn't contains field id"); string query = "SELECT "; //  !      foreach (field f in T) { if(field.index != 0) { query += ", "; } query += field.name; } query += "FROM " + name_of(T) + " WHERE ID=?ID"; //       ...................................................................................................................... //       Record r,         //   C++     Java?    T result = new T; //            foreach (field f in T) { result[f] = r.getFieldValue<f.type>(f.name); } return result; } 

अब हमारा कार्य स्थिर नहीं है, लेकिन इसके अलग-अलग टुकड़े स्थिर हैं, और काल्पनिक संकलक पूरे चक्रों को निष्पादित करता है, उन्हें निरंतर मूल्यों या बयानों के अनुक्रम के साथ प्रतिस्थापित करता है।

और यह मत कहो कि RTTI का आविष्कार यहाँ किया गया था! RTTI रन टाइम टाइप की जानकारी है, यह रनटाइम पर काम करता है। यहां, संकलक द्वारा निरंतर निर्देशों को निष्पादित करने के लिए संकलन समय पर टाइप जानकारी का उपयोग किया जाता है।

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

यह उत्सुक है कि उपरोक्त समस्या को कम से कम दो स्थिर भाषाओं में हल किया गया है (गतिशील भाषाओं में इसे समस्याओं के बिना हल किया जा सकता है)।

C # और VB.NET में निर्मित, LINQ आपको डेटाबेस के साथ सांख्यिकीय रूप से काम करने की अनुमति देता है। कई विशेषताओं को कानूनी रूप से लागू किया गया था: लंबोदर भाव, अनाम प्रकार, विधियों के ऑपरेटर रूप। लेकिन Microsoft ने टेबल और डेटाबेस फ़ील्ड [1] के साथ सांख्यिकीय रूप से घोषित वर्गों की जोड़ी के लिए "सीएलआर मेटाडेटा में एसक्यूएल स्कीमा जानकारी के एकीकरण" नामक आठवें स्तर के जादू का इस्तेमाल किया।

एक अन्य उदाहरण हास्केलबीडी लाइब्रेरी [2,3] है। खुद हास्केल, अपने भिक्षुओं के साथ, प्रथम-स्तरीय जादू के रूप में माना जा सकता है। लेकिन डेवलपर्स को "एक्स्टेंसिबल ट्रेक्स स्ट्रक्चर्स" नामक एक कस्टम भाषा एक्सटेंशन के रूप में तीसरे स्तर के जादू की आवश्यकता थी। और इसके बावजूद, डेटाबेस के साथ लिंक करने के लिए, संरचना के प्रत्येक क्षेत्र को अत्यधिक घोषणा देनी होगी। दो क्षेत्रों के साथ एक तालिका घोषित करने का उदाहरण:
students :: Table(name :: String, mark :: Char)
name :: r\name =>
Attr (name :: String | r) String
mark :: r\mark =>
Attr (mark :: Char | r) Char


हमारे नवाचारों के लाभों को बेहतर ढंग से समझने के लिए, मैं और उदाहरण प्रस्तुत करता हूं।
हमारे पास दो संरचनाएँ हैं:

 struct Order{ Date date; Client client; Product product; int qty; Numeric cost; }; struct Sales{ Product product; int qty; Numeric cost; }; 

कहीं न कहीं हमने ऑर्डर टू सेल्स से डेटा स्केल करने का फैसला किया

 void foo(Order o, Sales s){ foreach(field f in Sales){ s[f.name] = o[f.name]; } } 

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

ऑब्जेक्ट-ओरिएंटेड डिज़ाइन के क्षेत्र से एक उदाहरण:

 class Shape{ .............................. }; class Square: public Shape{ public: Square(); }; class Circle: public Shape{ public: Square(); }; .................................... // ,       //    ,   //     Shape* shapeFactory(string shapeName) { foreach(type T in descendants(Shape)){ if(name_of(T) == shapeName){ return new T; } return null; } 

संकलन के दौरान, आकृति निर्माण () एक नियमित कार्य में बदल जाएगा:

 Shape* shapeFactory(string shapeName) { if("Square" == shapeName){ return new Square; } if("Circle" == shapeName){ return new Circle; } return null; } 

संदर्भ:
1. LINQ: .NET भाषा-एकीकृत क्वेरी
2. आधिकारिक हास्केलबीडी प्रोजेक्ट पेज
3. डैन लीजेन, एरिक मीजर। डोमेन विशिष्ट एंबेडेड कम्पाइलर। एक लेख जो यह बताता है कि हास्केलबीडी कैसे काम करता है। एसक्यूएल और एक प्रोग्रामिंग भाषा की जोड़ी की समस्या पर भी चर्चा की गई है।