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

तर्क और पैरामीटर

पैरामीटर वह है जिसे हम स्वीकार करते हैं। पैरामीटर के प्रकार का वर्णन करते हुए, हम उन प्रकारों के सेट पर प्रतिबंध लगाते हैं जो हमारे लिए पारित किए जा सकते हैं। कुछ उदाहरण:

//   function log( id : string | number ) {} //   class Logger { constructor( readonly id : Natural ) {} } //   class Node< Id extends Number > { id : Id } 

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

 log( 123 ) //   new Logger( promptStringOrNumber( 'Enter id' ) ) //       new Node( 'root' ) //   ,   

उपप्रकार

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

एक उपप्रकार बनाने का दूसरा तरीका यह है कि इसे दूसरे प्रकार के ऑर्थोगोनल के साथ जोड़कर इसका विस्तार किया जाए। उदाहरण के लिए, संपत्ति "रंग" के साथ एक "रंग आंकड़ा" है, और संपत्ति "ऊंचाई" के साथ एक "वर्ग" है। इन प्रकारों के संयोजन से हमें एक "रंग वर्ग" मिलता है। और इसके "त्रिज्या" के साथ एक "सर्कल" जोड़कर हम एक "रंग सिलेंडर" प्राप्त कर सकते हैं।

अनुक्रम

आगे के कथन के लिए, हमें जानवरों के एक छोटे पदानुक्रम और कोशिकाओं के समान पदानुक्रम की आवश्यकता है।

 abstract class Animal {} abstract class Pet extends Animal {} class Cat extends Pet {} class Dog extends Pet {} class Fox extends Animal {} class AnimalCage { content : Animal } class PetCage extends AnimalCage { content : Pet } class CatCage extends PetCage { content : Cat } class DogCage extends PetCage { content : Dog } class FoxCage extends AnimalCage { content : Fox } 

नीचे सब कुछ ऊपर के प्रकार का एक संकुचन है। एक पालतू जानवर के साथ पिंजरे में केवल घरेलू जानवर हो सकते हैं, लेकिन जंगली जानवर नहीं। एक कुत्ते के साथ एक पिंजरे में केवल कुत्ते हो सकते हैं।

सहप्रसरण

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

 function touchPet( cage : PetCage ) : void { log( `touch ${cage.content}` ) } touchPet( new AnimalCage ) // forbid touchPet( new PetCage ) // allow touchPet( new CatCage ) // allow touchPet( new DogCage ) // allow touchPet( new FoxCage ) // forbid 

चूंकि हम पिंजरे में कुछ भी नहीं बदलते हैं, हम बिल्ली के साथ पिंजरे में सुरक्षित रूप से कार्यों को स्थानांतरित कर सकते हैं, क्योंकि यह एक पालतू जानवर के साथ पिंजरे के विशेष मामले से ज्यादा कुछ नहीं है।

contravariant

उपप्रकार प्रतिबंध या विरोधाभास को समझना थोड़ा कठिन है। निम्न उदाहरण में, फ़ंक्शन पैरामीटर इसके लिए निर्दिष्ट प्रकार के विपरीत है। यही है, फ़ंक्शन इस प्रकार को स्वयं और इसके किसी भी सुपरटेप दोनों को स्वीकार कर सकता है, लेकिन उपप्रकार या अन्य प्रकार स्वीकार नहीं कर सकता है।

 function pushPet( cage : PetCage ) : void { const Pet = random() > .5 ? Cat : Dog cage.content = new Pet } pushPet( new AnimalCage ) // allow pushPet( new PetCage ) // allow pushPet( new CatCage ) // forbid pushPet( new DogCage ) // forbid pushPet( new FoxCage ) // forbid 

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

निश्चरता

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

 function replacePet( cage : PetCage ) : void { touchPet( cage ) pushPet( cage ) } replacePet( new AnimalCage ) // forbid replacePet( new PetCage ) // allow replacePet( new CatCage ) // forbid replacePet( new DogCage ) // forbid replacePet( new FoxCage ) // forbid 

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

bivariant

लेकिन प्रतिबंधों की विदेशी अनुपस्थिति का उल्लेख नहीं किया जा सकता है - द्वैध। निम्नलिखित उदाहरण में, एक फ़ंक्शन किसी भी प्रकार को स्वीकार कर सकता है जो एक उपप्रकार या उपप्रकार है।

 function enshurePet( cage : PetCage ) : void { if( cage.content instanceof Pet ) return pushPet( cage ) } replacePet( new AnimalCage ) // allow replacePet( new PetCage ) // allow replacePet( new CatCage ) // allow replacePet( new DogCage ) // allow replacePet( new FoxCage ) // forbid 

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

सामान्यीकरण

कुछ का मानना ​​है कि विचरण किसी तरह सामान्यीकरण से संबंधित है। अक्सर क्योंकि प्रसरण को अक्सर उदाहरण के रूप में जेनेरिक कंटेनरों का उपयोग करके समझाया जाता है। हालाँकि, पूरी कहानी में अभी भी हमारा एक भी सामान्यीकरण नहीं हुआ है - यह पूरी तरह से ठोस वर्ग है:

 class AnimalCage { content : Animal } class PetCage extends AnimalCage { content : Pet } class CatCage extends PetCage { content : Cat } class DogCage extends PetCage { content : Dog } class FoxCage extends AnimalCage { content : Fox } 

यह दिखाने के लिए किया गया था कि विचरण की समस्याएं सामान्यीकरण से नहीं जुड़ी हैं। कॉपी-पेस्ट को कम करने के लिए सामान्यीकरण की आवश्यकता होती है। उदाहरण के लिए, ऊपर दिए गए कोड को एक सामान्य सामान्यीकरण के माध्यम से फिर से लिखा जा सकता है:

 class Cage<Animal> { content : Animal } 

और अब आप किसी भी सेल के उदाहरण बना सकते हैं:

 const animalCage = new Cage<Animal>() const petCage = new Cage<Pet>() const catCage = new Cage<Cat>() const dogCage = new Cage<Dog>() const foxCage = new Cage<Fox>() 

सीमाओं की घोषणा

कृपया ध्यान दें कि पहले से सूचीबद्ध सभी चार कार्यों के हस्ताक्षर बिल्कुल समान हैं:

 ( cage : PetCage )=> void 

यही है, फ़ंक्शन के स्वीकृत मापदंडों के ऐसे विवरण में पूर्णता नहीं है - यह कहा नहीं जा सकता है कि इसे फ़ंक्शन में स्थानांतरित किया जा सकता है। खैर, जब तक यह स्पष्ट रूप से नहीं देखा जाता है कि यह निश्चित रूप से लोमड़ी के साथ पिंजरे को पारित करने के लायक नहीं है।

इसलिए, आधुनिक भाषाओं में स्पष्ट रूप से यह इंगित करने के लिए एक साधन है कि पैरामीटर किस प्रकार का प्रतिबंध है। उदाहरण के लिए, C # में और बाहर संशोधक:

 interface ICageIn<in T> { T content { set; } } // contravariant generic parameter interface ICageOut<out T> { T content { get; } } // covariant generic parameter interface ICageInOut<T> { T content { get; set; } } // invariant generic parameter 

दुर्भाग्य से, सी # में प्रत्येक प्रकार के संशोधक के लिए एक अलग इंटरफ़ेस पर शुरू करना आवश्यक है। इसके अलावा, जैसा कि मैं इसे समझता हूं, सी # में द्विभाजक आमतौर पर अक्षम्य है।

आउटपुट पैरामीटर

कार्य न केवल स्वीकार कर सकते हैं, बल्कि मान भी लौटा सकते हैं। सामान्य तौर पर, वापसी मूल्य एक नहीं हो सकता है। एक उदाहरण के रूप में, एक पालतू जानवर के साथ एक पिंजरे लेने और दो पालतू जानवरों को लौटाने का कार्य करें।

 function getPets( input : PetCage ) : [ Pet , Pet ] { return [ input.content , new Cat ] } 

ऐसा फ़ंक्शन एक इनपुट पैरामीटर के बराबर होता है, जिसमें एक इनपुट पैरामीटर के अलावा दो और आउटपुट होते हैं।

 function getPets( input : PetCage , output1 : PetCage , output2 : PetCage ) : void { output1.content = input.content output2.content = new Cat } 

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

इन दो कार्यों की समानता से यह निम्नानुसार है कि फ़ंक्शन द्वारा लौटाए गए मान, मापदंडों के विपरीत, हमेशा निर्दिष्ट आउटपुट प्रकार के विपरीत होते हैं। एक समारोह के लिए उन्हें लिख सकते हैं, लेकिन उनसे नहीं पढ़ सकते हैं।

ऑब्जेक्ट तरीके

ऑब्जेक्ट विधियाँ एक फ़ंक्शनल पैरामीटर के रूप में ऑब्जेक्ट के लिए एक अतिरिक्त पॉइंटर लेने वाले फ़ंक्शन हैं। अर्थात्, निम्नलिखित दो कार्य समतुल्य हैं।

 class PetCage { pushPet() : void { const Pet = random() > .5 ? Cat : Dog this.content = new Pet } } 

 function pushPet( this : PetCage ) : void { const Pet = random() > .5 ? Cat : Dog this.content = new Pet } 

हालांकि, यह ध्यान रखना महत्वपूर्ण है कि एक विधि, एक नियमित कार्य के विपरीत, वर्ग का एक सदस्य भी है, जो कि प्रकार का एक विस्तार है। यह इस तथ्य की ओर जाता है कि इस पद्धति को कॉल करने वाले कार्यों के लिए एक अतिरिक्त सुपरटाइप प्रतिबंध दिखाई देता है:

 function fillPetCage( cage : PetCage ) { cage.pushPet() } 

हम इस तरह के एक pushPet को पास नहीं कर सकते हैं जहां pushPet विधि pushPet अभी तक परिभाषित नहीं किया गया है। यह आक्रमण के मामले के समान है जिसमें नीचे और ऊपर दोनों से प्रतिबंध है। हालांकि, pushPet विधि का स्थान पदानुक्रम में अधिक हो सकता है। और वह वह जगह है जहां ओवरटाइप सीमा होगी।

बारबरा लिस्क प्रतिस्थापन सिद्धांत (एलएसपी)

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

आधार प्रकार का उपयोग करने वाले कार्य यह जानने के बिना और कार्यक्रम की शुद्धता का उल्लंघन किए बिना आधार प्रकार के उपप्रकार का उपयोग करने में सक्षम होना चाहिए।

अपरिवर्तनीय (उन लोगों के लिए, जो उत्परिवर्तित नहीं हैं) सहित, इस सिद्धांत को स्वचालित रूप से निष्पादित किया जाता है, क्योंकि इसमें से उपप्रकार प्रतिबंध लेने की कोई जगह नहीं है।

उत्परिवर्तनों के साथ, यह अधिक से अधिक कठिन है, चूंकि निम्न दो स्थितियां एलएसपी सिद्धांत के लिए पारस्परिक रूप से अनन्य हैं:

1. कक्षा A में B उपवर्ग है, जहाँ फ़ील्ड B::foo , A::foo का उप-प्रकार है।
2. क्लास A में एक विधि है जो A::foo फील्ड को बदल सकती है।

तदनुसार, केवल तीन तरीके बचे हैं:

1. वस्तुओं को उनके क्षेत्र प्रकारों को संकुचित करने से विरासत में आने से रोकें। लेकिन फिर आप एक बिल्ली के लिए एक हाथी को पिंजरे में बंद कर सकते हैं।
2. एलएसपी द्वारा निर्देशित नहीं, बल्कि प्रत्येक फ़ंक्शन के प्रत्येक पैरामीटर की परिवर्तनशीलता द्वारा अलग-अलग। लेकिन फिर आपको बहुत सोचना होगा और संकलक को समझाना होगा कि प्रकार के प्रतिबंध कहां हैं।
3. सब कुछ पर थूकना और जाना मठ कार्यात्मक प्रोग्रामिंग, जहां सभी ऑब्जेक्ट अपरिवर्तनीय हैं, जिसका अर्थ है कि स्वीकार करने वाले उनके पैरामीटर घोषित प्रकार के सहसंयोजक हैं।

टाइपप्रति

स्क्रिप्ट में तर्क सरल है: फ़ंक्शन के सभी मापदंडों को सहसंयोजक (जो सच नहीं है) माना जाता है, और वापसी मान को कंट्रावेरिएंट (जो सच है) माना जाता है। यह पहले दिखाया गया था कि एक फ़ंक्शन के मापदंडों में बिल्कुल भिन्नता हो सकती है, जो इस कार्य को इन मापदंडों के साथ करती है। इसलिए, ये निम्नलिखित घटनाएं हैं:

 abstract class Animal { is! : 'cat' | 'dog' | 'fox' } abstract class Pet extends Animal { is! : 'cat' | 'dog' } class Cat extends Pet { is! : 'cat' } class Dog extends Pet { is! : 'dog' } class Fox extends Animal { is! : 'fox' } class Cage<Animal> { content! : Animal } function pushPet( cage : Cage<Pet> ) : void { const Pet = Math.random() > .5 ? Cat : Dog cage.content = new Pet } pushPet( new Cage<Animal>() ) // forbid to push Pet to Animal Cage :-( pushPet( new Cage<Cat>() ) // allow to push Dog to Cat Cage :-( 

इस समस्या को हल करने के लिए, आपको संवेदी कोड के बजाय संकलक की मदद करनी होगी:

 function pushPet< PetCage extends Cage<Animal> >( cage: Cage<Pet> extends PetCage ? PetCage : never ): void { const Pet = Math.random() > .5 ? Cat : Dog cage.content = new Pet } pushPet( new Cage<Animal>() ) // allow :-) pushPet( new Cage<Pet>() ) // allow :-) pushPet( new Cage<Cat>() ) // forbid :-) pushPet( new Cage<Dog>() ) // forbid :-) pushPet( new Cage<Fox>() ) // forbid :-) 

ऑनलाइन कोशिश करें

FlowJS

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

 class Animal {} class Pet extends Animal {} class Cat extends Pet {} class Dog extends Pet {} class Fox extends Animal {} class Cage< Animal > { content : Animal } function touchPet( cage : { +content : Pet } ) : void { console.log( `touch ${typeof cage.content}` ) } function pushPet( cage: { -content: Pet } ): void { const Pet = Number((0: any)) > .5 ? Cat : Dog cage.content = new Pet } function replacePet( cage : { content : Pet } ) : void { touchPet( cage ) pushPet( cage ) } touchPet( new Cage<Animal> ) // forbid :-) touchPet( new Cage<Pet> ) // allow :-) touchPet( new Cage<Cat> ) // allow :-) touchPet( new Cage<Dog> ) // allow :-) touchPet( new Cage<Fox> ) // forbid :-) pushPet( new Cage<Animal> ) // allow :-) pushPet( new Cage<Pet> ) // allow :-) pushPet( new Cage<Cat> ) // forbid :-) pushPet( new Cage<Dog> ) // forbid :-) pushPet( new Cage<Fox> ) // forbid :-) replacePet( new Cage<Animal> ) // forbid :-) replacePet( new Cage<Pet> ) // allow :-) replacePet( new Cage<Cat> ) // forbid :-) replacePet( new Cage<Dog> ) // forbid :-) replacePet( new Cage<Fox>) // forbid :-) 

ऑनलाइन कोशिश करें

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

 function pushPet( cage: Contra< Cage<Pet> , 'content' > ): void { const Pet = Number((0: any)) > .5 ? Cat : Dog cage.content = new Pet } 

सी तेज

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

 using System; abstract class Animal {} abstract class Pet : Animal {} class Cat : Pet {} class Dog : Pet {} class Fox : Animal {} interface ICageIn<in T> { T content { set; } } interface ICageOut<out T> { T content { get; } } interface ICageInOut<T> { T content { get; set; } } class Cage<T> : ICageIn<T>, ICageOut<T>, ICageInOut<T> { public T content { get; set; } } public class Program { static void touchPet( ICageOut<Pet> cage ) { Console.WriteLine( cage.content ); } static void pushPet( ICageIn<Pet> cage ) { cage.content = new Dog(); } static void replacePet( ICageInOut<Pet> cage ) { touchPet( cage as ICageOut<Pet> ); pushPet( cage as ICageIn<Pet> ); } void enshurePet( Cage<Pet> cage ) { if( cage.content is Pet ) return; pushPet( cage as ICageIn<Pet> ); } public static void Main() { var animalCage = new Cage<Animal>(); var petCage = new Cage<Pet>(); var catCage = new Cage<Cat>(); var dogCage = new Cage<Dog>(); var foxCage = new Cage<Fox>(); touchPet( animalCage ); // forbid :-) touchPet( petCage ); // allow :-) touchPet( catCage ); // allow :-) touchPet( dogCage ); // allow :-) touchPet( foxCage ); // forbid :-) pushPet( animalCage ); // allow :-) pushPet( petCage ); // allow :-) pushPet( catCage ); // forbid :-) pushPet( dogCage ); // forbid :-) pushPet( foxCage ); // forbid :-) replacePet( animalCage ); // forbid :-) replacePet( petCage ); // allow :-) replacePet( catCage ); // forbid :-) replacePet( dogCage ); // forbid :-) replacePet( foxCage ); // forbid :-) } } 

ऑनलाइन कोशिश करें

जावा

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

 abstract class Animal {} abstract class Pet extends Animal {} class Cat extends Pet {} class Dog extends Pet {} class Fox extends Animal {} class Cage<T> { public T content; } public class Main { static void touchPet( Cage<? extends Pet> cage ) { System.out.println( cage.content ); } static void pushPet( Cage<? super Pet> cage ) { cage.content = new Dog(); } static void replacePet(Cage<Pet> cage ) { touchPet( cage ); pushPet( cage ); } void enshurePet( Cage<Pet> cage ) { if( cage.content instanceof Pet ) return; pushPet( cage ); } public static void main(String[] args) { Cage<Animal> animalCage = new Cage<Animal>(); Cage<Pet> petCage = new Cage<Pet>(); Cage<Cat> catCage = new Cage<Cat>(); Cage<Dog> dogCage = new Cage<Dog>(); Cage<Fox> foxCage = new Cage<Fox>(); touchPet( animalCage ); // forbid :-) touchPet( petCage ); // allow :-) touchPet( catCage ); // allow :-) touchPet( dogCage ); // allow :-) touchPet( foxCage ); // forbid :-) pushPet( animalCage ); // allow :-) pushPet( petCage ); // allow :-) pushPet( catCage ); // forbid :-) pushPet( dogCage ); // forbid :-) pushPet( foxCage ); // forbid :-) replacePet( animalCage ); // forbid :-) replacePet( petCage ); // allow :-) replacePet( catCage ); // forbid :-) replacePet( dogCage ); // forbid :-) replacePet( foxCage ); // forbid :-) } } 

ऑनलाइन कोशिश करें

सी ++

सी ++, अपने शक्तिशाली टेम्पलेट सिस्टम के लिए धन्यवाद, विभिन्न विविधताएं व्यक्त कर सकता है, लेकिन निश्चित रूप से बहुत कोड है।

 #include <iostream> #include <typeinfo> #include <type_traits> class Animal {}; class Pet: public Animal {}; class Cat: public Pet {}; class Dog: public Pet {}; class Fox: public Animal {}; template<class T> class Cage { public: T *content; }; template<class T, class = std::enable_if_t<std::is_base_of<Pet, T>::value>> void touchPet(const Cage<T> &cage) { std::cout << typeid(T).name(); } template<class T, class = std::enable_if_t<std::is_base_of<T, Pet>::value>> void pushPet(Cage<T> &cage) { cage.content = new Dog(); } void replacePet(Cage<Pet> &cage) { touchPet(cage); pushPet(cage); } int main(void) { Cage<Animal> animalCage {new Fox()}; Cage<Pet> petCage {new Cat()}; Cage<Cat> catCage {new Cat()}; Cage<Dog> dogCage {new Dog()}; Cage<Fox> foxCage {new Fox()}; touchPet( animalCage ); // forbid :-) touchPet( petCage ); // allow :-) touchPet( catCage ); // allow :-) touchPet( dogCage ); // allow :-) touchPet( foxCage ); // forbid :-) pushPet( animalCage ); // allow :-) pushPet( petCage ); // allow :-) pushPet( catCage ); // forbid :-) pushPet( dogCage ); // forbid :-) pushPet( foxCage ); // forbid :-) replacePet( animalCage ); // forbid :-) replacePet( petCage ); // allow :-) replacePet( catCage ); // forbid :-) replacePet( dogCage ); // forbid :-) replacePet( foxCage ); // forbid :-) return 0; } 

ऑनलाइन कोशिश करें

डी

D के पास स्पष्ट रूप से विचरण का संकेत देने वाला कोई भी संतान नहीं है, लेकिन वह जानता है कि उनके उपयोग के आधार पर किस प्रकार का अनुमान लगाना है।

 import std.stdio, std.random; abstract class Animal {} abstract class Pet : Animal { string name; } class Cat : Pet {} class Dog : Pet {} class Fox : Animal {} class Cage(T) { T content; } void touchPet( PetCage )( PetCage cage ) { writeln( cage.content.name ); } void pushPet( PetCage )( PetCage cage ) { cage.content = ( uniform(0,2) > 0 ) ? new Dog() : new Cat(); } void replacePet( PetCage )( PetCage cage ) { touchPet( cage ); pushPet( cage); } void main() { Cage!Animal animalCage; Cage!Pet petCage; Cage!Cat catCage; Cage!Dog dogCage; Cage!Fox foxCage; animalCage.touchPet(); // forbid :-) petCage.touchPet(); // allow :-) catCage.touchPet(); // allow :-) dogCage.touchPet(); // allow :-) foxCage.touchPet(); // forbid :-) animalCage.pushPet(); // allow :-) petCage.pushPet(); // allow :-) catCage.pushPet(); // forbid :-) dogCage.pushPet(); // forbid :-) foxCage.pushPet(); // forbid :-) animalCage.replacePet(); // forbid :-) petCage.replacePet(); // allow :-) catCage.replacePet(); // forbid :-) dogCage.replacePet(); // forbid :-) foxCage.replacePet(); // forbid :-) } 

ऑनलाइन कोशिश करें

उपसंहार

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