जंग में जेनेरिक प्रकार बंद

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

समस्या

जंग में, एक विकसित स्थिर प्रकार की प्रणाली और इसकी स्थिर क्षमताएं शायद 80% मामलों के लिए पर्याप्त हैं। लेकिन ऐसा होता है कि जब आप एक ही स्थान पर विभिन्न प्रकार की वस्तुओं को स्टोर करना चाहते हैं तो डायनामिक टाइपिंग की आवश्यकता होती है। चरित्र प्रकार-ऑब्जेक्ट यहां बचाव के लिए आते हैं: वे वास्तविक प्रकार की वस्तुओं को मिटा देते हैं, उन्हें प्रकार द्वारा परिभाषित एक निश्चित सामान्य इंटरफ़ेस में कम कर देते हैं, और फिर आप इन वस्तुओं पर उसी प्रकार-प्रकार-ऑब्जेक्ट के रूप में काम कर सकते हैं।

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

निर्णय

सभी प्रकार के 'static प्रकारों के लिए (अर्थात, ऐसे प्रकार जिनमें गैर-स्थैतिक लिंक नहीं होते हैं), जंग Any प्रकार को लागू करता है, जो मूल के प्रकार के संदर्भ के लिए dyn Any प्रकार-वस्तु के रूपांतरण की अनुमति देता है:

 let value = "test".to_string(); let value_any = &value as &dyn Any; //       String.  //   -      . if let Some(as_string) = value_any.downcast_ref::<String>() { println!("String: {}", as_string); } else { println!("Unknown type"); } 

प्रारंभ

इस उद्देश्य के लिए Box downcast विधि भी है।

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

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

कार्यान्वयन

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

 enum Node { Prim(Primitive), Comp(Component), } struct Primitive { shape: Shape, children: Vec<Node>, } struct Component { node: Box<Node>, } enum Shape { Rectangle, Circle, } 

Component संरचना में Node पैकेजिंग आवश्यक है क्योंकि Component संरचना का उपयोग Node में किया जाता है।

अब मान लीजिए कि हमारा पेड़ केवल कुछ मॉडल का प्रतिनिधित्व करता है जिसके साथ इसे जुड़ा होना चाहिए। इसके अलावा, प्रत्येक घटक का अपना मॉडल होगा:

 struct Primitive<Model> { shape: Shape, children: Vec<Node<Model>>, } struct Component<Model> { node: Box<Node<Model>>, model: Model, //   Model } 

हम लिख सकते हैं:

 enum Node<Model> { Prim(Primitive<Model>), Comp(Component<Model>), } 

लेकिन यह कोड हमारी जरूरत के अनुसार काम नहीं करेगा। क्योंकि घटक का अपना मॉडल होना चाहिए, न कि मूल तत्व का मॉडल, जिसमें घटक होता है। यही है, हमें इसकी आवश्यकता है:

 enum Node<Model> { Prim(Primitive<Model>), Comp(Component), } struct Primitive<Model> { shape: Shape, children: Vec<Node<Model>>, _model: PhantomData<Model>, //   Model } struct Component { node: Box<dyn Any>, model: Box<dyn Any>, } impl Component { fn new<Model: 'static>(node: Node<Model>, model: Model) -> Self { Self { node: Box::new(node), model: Box::new(model), } } } 

प्रारंभ

हमने एक विशिष्ट प्रकार के मॉडल के संकेत को new विधि में स्थानांतरित कर दिया है, और घटक में ही हम मॉडल और सबट्री को पहले से ही मिटाए गए प्रकारों के साथ संग्रहीत करते हैं।

अब use_model विधि जोड़ें, जो मॉडल का उपयोग करेगा, लेकिन इसके प्रकार द्वारा पैरामीटर नहीं किया जाएगा:

 struct Component { node: Box<dyn Any>, model: Box<dyn Any>, use_model_closure: fn(&Component), } impl Component { fn new<Model: 'static>(node: Node<Model>, model: Model) -> Self { let use_model_closure = |comp: &Component| { comp.model.downcast_ref::<Model>().unwrap(); }; Self { node: Box::new(node), model: Box::new(model), use_model_closure, } } fn use_model(&self) { (self.use_model_closure)(self); } } 

प्रारंभ

ध्यान दें कि घटक में हम एक पॉइंटर को एक फ़ंक्शन में संग्रहीत करते हैं जो एक बंद को परिभाषित करने के लिए सिंटैक्स का उपयोग करके new विधि में बनाया गया है। लेकिन यह सब बाहर से कब्जा करना चाहिए यह Model प्रकार है, इसलिए हमें एक तर्क के माध्यम से इस फ़ंक्शन में घटक के लिए एक लिंक पास करने के लिए मजबूर किया जाता है।

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

use_model विधि का उपयोग use_model ऐसे संदर्भ में किया जा सकता है जहां वास्तविक प्रकार का Model अज्ञात है। उदाहरण के लिए, विभिन्न मॉडलों के साथ कई अलग-अलग घटकों से मिलकर एक पुनरावर्ती ट्री ट्रैवर्सल में।

विकल्प

यदि घटक के इंटरफ़ेस को उस प्रकार में स्थानांतरित करना संभव है जो किसी प्रकार-ऑब्जेक्ट के निर्माण की अनुमति देता है, तो ऐसा करना बेहतर है, और इसके बजाय अपने टाइप-ऑब्जेक्ट पर काम करने के लिए घटक का उपयोग करें:

 enum Node<Model> { Prim(Primitive<Model>), Comp(Box<dyn ComponentApi>), } struct Component<Model> { node: Node<Model>, model: Model, } impl<Model> Component<Model> { fn new(node: Node<Model>, model: Model) -> Self { Self { node, model, } } } trait ComponentApi { fn use_model(&self); } impl<Model> ComponentApi for Component<Model> { fn use_model(&self) { &self.model; } } 

प्रारंभ

निष्कर्ष

यह पता चला है कि जंग में बंद होने से न केवल पर्यावरण वस्तुओं पर कब्जा हो सकता है, बल्कि प्रकार भी हो सकते हैं। हालांकि, उन्हें साधारण कार्यों के रूप में व्याख्या किया जा सकता है। यह गुण तब उपयोगी हो जाता है जब आपको उनके बारे में जानकारी के बिना समान प्रकार के साथ समान रूप से काम करने की आवश्यकता होती है, यदि चरित्र प्रकार लागू नहीं होते हैं।

मुझे उम्मीद है कि यह लेख आपको जंग का उपयोग करने में मदद करेगा। अपने विचार कमेंट में शेयर करें।