Rust में डिज़ाइन पैटर्न: कोड उदाहरणों के साथ उन्नत तकनीकें

Rust में उदाहरणों के साथ डिज़ाइन पैटर्न: उन्नत स्तर

Rust एक ऐसी भाषा है जो डिज़ाइन के दृष्टिकोण को बदल देती है। GoF के क्लासिक पैटर्न को अक्सर स्वामित्व की सख्त प्रणाली, जीवनकाल और वंशानुक्रम की कमी के कारण अनुकूलन की आवश्यकता होती है। इस लेख में, हम उन्नत डिज़ाइन पैटर्न पर चर्चा करेंगे जो न केवल Rust में काम करते हैं, बल्कि इसकी ताकत का उपयोग करते हैं: मेमोरी सुरक्षा, zero-cost अमूर्तता और एक शक्तिशाली प्रकार प्रणाली।

1. कंपाइल-टाइम जाँच के साथ Builder पैटर्न

Rust में क्लासिक Builder आमतौर पर वैकल्पिक फ़ील्ड वाली संरचना के माध्यम से कार्यान्वित किया जाता है। उन्नत स्तर पर, हम कंपाइल-टाइम पर आवश्यक फ़ील्ड की जाँच करने के लिए प्रकार प्रणाली का उपयोग कर सकते हैं। यह "आवश्यक फ़ील्ड सेट करना भूल गए" रनटाइम त्रुटियों को समाप्त करता है।

Type State (प्रकार अवस्था) के माध्यम से कार्यान्वयन Builder को सुरक्षित और स्व-दस्तावेजीकरण बनाता है।

// Builder के लिए अवस्थाएँstruct Empty;struct WithName(String);struct WithAge(u8);struct Ready(WithName, WithAge);

struct PersonBuilder<State> {    state: State,}

impl PersonBuilder<Empty> {    pub fn new() -> Self {        PersonBuilder { state: Empty }    }        pub fn name(self, name: &str) -> PersonBuilder<WithName> {        PersonBuilder {            state: WithName(name.to_string()),        }    }}

impl PersonBuilder<WithName> {    pub fn age(self, age: u8) -> PersonBuilder<Ready> {        PersonBuilder {            state: Ready(self.state, WithAge(age)),        }    }}

impl PersonBuilder<Ready> {    pub fn build(self) -> Person {        Person {            name: self.state.0 .0,            age: self.state.1 .0,        }    }}

struct Person {    name: String,    age: u8,}

fn main() {    // कंपाइल होता है - सभी फ़ील्ड सेट हैं    let person = PersonBuilder::new()        .name("Alice")        .age(30)        .build();        // कंपाइल नहीं होगा: name() गायब है    // let person = PersonBuilder::new().age(30).build();        println!("{} is {} years old", person.name, person.age);}

लाभ: कॉन्फ़िगरेशन त्रुटियाँ निष्पादन के दौरान नहीं, बल्कि कंपाइल-टाइम पर पकड़ी जाती हैं। यह दर्जनों मापदंडों वाली जटिल वस्तुओं के लिए विशेष रूप से मूल्यवान है।

2. संसाधन प्रबंधन के लिए RAII पैटर्न और स्मार्ट पॉइंटर्स

RAII (Resource Acquisition Is Initialization) केवल एक पैटर्न नहीं है, बल्कि Rust का दर्शन है। प्रत्येक संसाधन (मेमोरी, फ़ाइल, सॉकेट, लॉक) को कंस्ट्रक्टर में प्राप्त किया जाना चाहिए और डिस्ट्रक्टर में मुक्त किया जाना चाहिए। Rust इसे Drop ट्रेट और स्वामित्व प्रणाली के माध्यम से कार्यान्वित करता है।

उन्नत उदाहरण - स्वचालित मुक्ति के साथ म्यूटेक्स के लिए RAII रैपर बनाना।

use std::ops::Deref;use std::sync::{Arc, Mutex};

struct Guard<T> {    data: T,}

impl<T> Drop for Guard<T> {    fn drop(&mut self) {        println!("संसाधन मुक्त हो गया!");    }}

impl<T> Deref for Guard<T> {    type Target = T;    fn deref(&self) -> &Self::Target {        &self.data    }}

struct ResourceManager<T> {    resource: Arc<Mutex<T>>,}

impl<T> ResourceManager<T> {    fn new(data: T) -> Self {        ResourceManager {            resource: Arc::new(Mutex::new(data)),        }    }        fn acquire(&self) -> Guard<std::sync::MutexGuard<T>> {        let guard = self.resource.lock().unwrap();        Guard { data: guard }    }}

fn main() {    let manager = ResourceManager::new(42);    {        let guard = manager.acquire();        println!("मान: {}", *guard);        // guard दायरे से बाहर जाता है -> स्वचालित रूप से म्यूटेक्स मुक्त करता है    } // प्रिंट करता है "संसाधन मुक्त हो गया!"        println!("म्यूटेक्स फिर से उपलब्ध है");}

मुख्य विचार: डिस्ट्रक्टर को