शून्य को "खाली संरचना" के रूप में सोचें। मुझे समझाने दो।
प्रत्येक फ़ंक्शन मापदंडों का एक क्रम लेता है, जहां प्रत्येक पैरामीटर का एक प्रकार होता है। वास्तव में, हम मापदंडों के अनुरूप संरचना स्लॉट के साथ एक संरचना में मापदंडों को पैकेज कर सकते हैं। इससे प्रत्येक फ़ंक्शन का एक तर्क होता है। इसी तरह, फ़ंक्शन एक परिणाम का उत्पादन करते हैं, जिसमें एक प्रकार होता है। यह एक बूलियन हो सकता है, या यह फ्लोट हो सकता है, या यह एक संरचना हो सकती है, जिसमें अन्य टाइप किए गए मानों का एक मनमाना सेट होता है। यदि हम एक ऐसी छूट चाहते हैं जिसमें कई रिटर्न मान हों, तो यह आसान है कि वे केवल एक संरचना में पैक किए जाएं। वास्तव में, हम हमेशा जोर देकर कह सकते हैं कि एक फ़ंक्शन ने एक संरचना लौटा दी। अब प्रत्येक फ़ंक्शन ठीक एक तर्क लेता है, और ठीक एक मान पैदा करता है।
अब, क्या होता है जब मुझे एक फ़ंक्शन की आवश्यकता होती है जो "नहीं" मान पैदा करता है? खैर, विचार करें कि जब मुझे 3 स्लॉट्स के साथ एक संरचना बनाते हैं तो मुझे क्या मिलता है: यह 3 मान रखता है। जब मेरे पास 2 स्लॉट होते हैं, तो यह दो मान रखता है। जब इसका एक स्लॉट होता है, तो एक मूल्य। और जब यह शून्य स्लॉट होता है, तो यह ... उह, शून्य मान, या "कोई" मूल्य "नहीं होता है। इसलिए, मैं एक फ़ंक्शन को शून्य मानकर वापस लौट सकता हूं, जिसमें कोई मान नहीं है, जिसमें आप" शून्य "भी तय कर सकते हैं। भाषा में एक कीवर्ड के बजाय खाली संरचना द्वारा दर्शाए गए प्रकार का केवल एक पर्याय है (शायद इसका सिर्फ एक पूर्वनिर्धारित प्रकार :)
इसी तरह, मैं एक फ़ंक्शन के बारे में सोच सकता हूं जिसमें खाली संरचना को स्वीकार करने के लिए कोई मूल्य नहीं है, उदाहरण के लिए, "शून्य"।
मैं अपनी प्रोग्रामिंग भाषा को इस तरह भी लागू कर सकता हूं। शून्य मान को पास करना शून्य बाइट्स लेता है, इसलिए शून्य मान को पार करना मनमाने आकार के अन्य मूल्यों को पारित करने का एक विशेष मामला है। यह संकलक के लिए "शून्य" परिणाम या तर्क का इलाज करना आसान बनाता है। आप शायद एक लैंग्वेज सुविधा चाहते हैं जो एक फ़ंक्शन परिणाम को फेंक सकता है; सी में, यदि आप निम्न कथन में गैर-शून्य परिणाम फ़ंक्शन फू कहते हैं: फू (...); संकलक जानता है कि फू एक परिणाम पैदा करता है और बस इसे अनदेखा करता है। यदि शून्य एक मान है, तो यह पूरी तरह से काम करता है और अब "प्रक्रियाएं" (जो शून्य परिणाम वाले फ़ंक्शन के लिए एक विशेषण हैं) सामान्य कार्यों के केवल तुच्छ विशेष मामले हैं।
शून्य * थोड़ा मजेदार है। मुझे नहीं लगता कि सी डिजाइनरों ने उपरोक्त तरीके से शून्य के बारे में सोचा; उन्होंने सिर्फ एक कीवर्ड बनाया। वह कीवर्ड तब उपलब्ध था जब किसी को एक मनमाने प्रकार के बिंदु की आवश्यकता थी, इस प्रकार शून्य में * शून्य के रूप में। यह वास्तव में बहुत अच्छी तरह से काम करता है यदि आप रिक्त संरचना के रूप में शून्य की व्याख्या करते हैं। एक शून्य * पॉइंटर एक ऐसी जगह का पता है जहां उस खाली संरचना को रखा गया है।
अन्य प्रकार के टी के लिए शून्य * से टी * तक कास्ट, इस दृष्टिकोण के साथ भी काम करते हैं। पॉइंटर कास्ट एक पूर्ण धोखा है जो इस तथ्य का लाभ उठाने के लिए सबसे आम आर्किटेक्चर पर काम करता है कि यदि एक यौगिक प्रकार टी में उप-प्रकार एस के साथ एक तत्व है जो भौतिक रूप से टी की शुरुआत में इसके स्टोरेज लेआउट में रखा गया है, तो एस * से टी * तक कास्टिंग करें। एक ही भौतिक मशीन पते का उपयोग करने के विपरीत इसके विपरीत काम करना बंद हो जाता है, क्योंकि अधिकांश मशीन पॉइंटर्स में एक ही प्रतिनिधित्व होता है। प्रकार S द्वारा प्रकार V को प्रतिस्थापित करने से ठीक वैसा ही प्रभाव प्राप्त होता है, और इस प्रकार शून्य से / के लिए कास्टिंग कार्य करता है।
PARLANSE प्रोग्रामिंग भाषा उपरोक्त विचारों को बहुत बारीकी से लागू करती है। हमने इसके डिजाइन में नासमझी की, और वापसी प्रकार के रूप में "शून्य" पर पूरा ध्यान नहीं दिया और इस प्रकार प्रक्रिया के लिए लैंग्वेज कीवर्ड हैं। इसका ज्यादातर सिर्फ एक सरल वाक्यविन्यास है, लेकिन इसकी एक चीज़ जो आपको एक भाषा में एक बड़ा बॉडी वर्किंग कोड मिलने के बाद नहीं मिलती है।