अनुबंध और आश्रित टाइपिंग के बीच संबंध


31

मैं आश्रित प्रकार और प्रोग्रामिंग अनुबंधों पर कुछ लेख पढ़ रहा हूं। मैंने जो पढ़ा है, उसके बहुमत से, ऐसा लगता है कि अनुबंधों की गतिशील रूप से जांच की गई बाधाएं हैं और निर्भर प्रकारों को सांख्यिकीय रूप से जांचा जाता है।

ऐसे कुछ कागजात मिले हैं जिनसे मुझे लगा है कि अनुबंधों को आंशिक रूप से जाँचना संभव है:

इसके साथ, ओवरलैप की एक महत्वपूर्ण राशि प्रतीत होती है और मेरे अनुबंधों पर निर्भरता बनाम प्रकार गायब होने लगते हैं।

क्या दोनों अवधारणाओं में कुछ गहरा है जो मुझे याद आ रहा है? या ये वास्तव में एक ही अंतर्निहित अवधारणा का प्रतिनिधित्व करने की सिर्फ फजी श्रेणियां हैं?

जवाबों:


26

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

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

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

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


आप क्यों कहते हैं कि अनुबंध क्वांटिफायर मुक्त हैं?
रादु GRIGore

3
क्योंकि आप आम तौर पर कार्यों की सार्वभौमिक मात्रा निर्धारित गुणों को स्थापित करने के लिए परीक्षणों का उपयोग नहीं कर सकते, बस।
नील कृष्णस्वामी

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

2
@Radu: मैं JML और सह "प्रोग्राम लॉजिक्स" जैसी चीजों को कॉल करता हूं। कार्यक्रम लॉगिक्स की मुखर भाषाएं कार्यक्रमों की भाषा से शब्द होने तक ही सीमित नहीं हैं। इससे आप नॉनटर्मिंग या साइड-इफ़ेक्टिंग अभिकथन जैसी चीजों को नियंत्रित कर सकते हैं, जिनकी एक अच्छी तार्किक व्याख्या नहीं है। (हालांकि, इस तरह की चीजें कॉन्ट्रैक्ट चेकिंग के लिए बहुत मायने रखती हैं - Pucella और Tove के ईएसओपी के हालिया काम को स्टेटफुल, इंपॉर्टेंट कॉन्ट्रैक्ट्स को लीनियरिटी प्रॉपर्टीज को ट्रैक करने के लिए देखें।)
नील कृष्णास्वामी

2
ऐसा इसलिए क्योंकि मैंने तोव के आखिरी नाम को गलत बताया। "Affine Types के स्टेटफुल कॉन्ट्रैक्ट्स" देखें, ccs.neu.edu/home/tov/pubs/affine-contracts
नील कृष्णास्वामी

13

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

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

फलागन का काम दोनों दुनिया से सर्वश्रेष्ठ लेने की कोशिश करता है, ताकि आप जल्दी से टाइप-जैसे गुणों की जांच कर सकें और फिर बाकी के लिए श्रम कर सकें। मैं वास्तव में हाइब्रिड प्रकारों से परिचित नहीं हूं, लेकिन मुझे यह कहते हुए लेखक को याद है कि उनकी प्रेरणा एक ऐसे समाधान के साथ आई थी जिसमें कम एनोटेशन की आवश्यकता होती है (ईएससी / जावा पर अपने पिछले काम की तुलना में)। एक अर्थ में, हालांकि, ESC / Java (और Spec #) में प्रकार और अनुबंधों के बीच कुछ ढीले एकीकरण हैं: अनुबंधों की जांच करते समय, सॉल्वर को बताया जाता है कि टाइप-चेकिंग सफल रही इसलिए यह उस जानकारी को देख सकता है।


7

अनुबंधों को सांख्यिकीय रूप से जांचा जा सकता है। यदि आप ईएससी / हास्केल पर दाना जू के पुराने काम को देखते हैं , तो वह संकलन समय पर पूर्ण अनुबंध की जाँच को लागू करने में सक्षम था, केवल अंकगणित के लिए एक प्रमेय कहावत पर निर्भर था। यदि मुझे सही तरीके से याद है तो समाप्ति को एक सरल गहराई सीमा द्वारा हल किया जाता है:


6

दोनों अनुबंध और प्रकार आपको कार्यों पर होरे-शैली (पूर्व / पोस्ट स्थिति) विनिर्देशों का प्रतिनिधित्व करने की अनुमति देते हैं। दोनों को संकलित समय पर या गतिशील रूप से रनटाइम पर या तो जाँच की जा सकती है।

आश्रित प्रकार आपको टाइप सिस्टम में गुणों की एक बहुत विस्तृत श्रृंखला को एन्कोड करने की अनुमति देते हैं, जो प्रोग्रामर अनुबंध की अपेक्षा करते हैं। ऐसा इसलिए है क्योंकि वे प्रकार के मूल्यों पर निर्भर कर सकते हैं । आश्रित प्रकारों को सांख्यिकीय रूप से जांचने की प्रवृत्ति होती है, हालांकि मेरा मानना ​​है कि आपके द्वारा देखे गए कागजात वैकल्पिक दृष्टिकोण को देखते हैं।

अंतत: थोड़ा अंतर है। मुझे लगता है कि यह अधिक है कि आश्रित प्रकार एक तर्क है जिसमें आप विशिष्टताओं को व्यक्त कर सकते हैं जबकि अनुबंध एक प्रोग्रामिंग पद्धति है जिसमें आप विशिष्टताओं को व्यक्त करते हैं।


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

1
मैं इस धारणा के अधीन था कि प्रमाण उत्पन्न करना असाध्य हो सकता है लेकिन प्रमाण की जाँच होनी चाहिए। कई निर्भर प्रकार की भाषाएं प्रमेय-प्रकार के निवासियों के प्रमाण-मूल्य की आपूर्ति करने के लिए उपयोगकर्ता पर निर्भर करती हैं।
जेसन रीच

तुम सही हो। लेकिन मैं स्वचालित दुनिया में रहता हूं, जहां उपयोगकर्ता से आमतौर पर प्रमाण नहीं मांगा जाता है।
राडू ग्रिगोर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.