Iterators और Closures (Iterators and Closures in Rust)

Rust में Iterators और Closures आपके कोड को अधिक लचीला और संक्षिप्त बनाने में मदद करते हैं। Iterators का उपयोग डेटा संरचनाओं (जैसे Vectors और HashMaps) के तत्वों को एक-एक करके एक्सेस करने के लिए किया जाता है, जबकि Closures छोटे और अनाम फ़ंक्शंस होते हैं जिन्हें आप ऑन-द-फ्लाई परिभाषित कर सकते हैं। इस अध्याय में, हम Iterators और Closures के उपयोग, उनकी कार्यक्षमता, और उनके द्वारा प्रदान की जाने वाली लचीलापन और संक्षिप्तता को समझेंगे।

Iterators का परिचय (Introduction to Iterators)

Rust में Iterators का उपयोग डेटा संरचनाओं (जैसे Vectors, Arrays, HashMaps) के तत्वों को एक-एक करके एक्सेस करने के लिए किया जाता है। एक Iterator वह इकाई है, जो किसी संग्रह (collection) के तत्वों पर traversal (क्रमवार चलना) करता है, यानी यह किसी सूची या अन्य संग्रह के हर तत्व को एक-एक करके रिटर्न करता है। Rust में Iterators एक lazy abstraction हैं, जिसका मतलब है कि जब तक आप तत्वों को एक्सेस नहीं करते, तब तक कोई वास्तविक कार्य नहीं होता।

Iterators Rust में बेहद शक्तिशाली होते हैं, क्योंकि वे आपको कोड को संक्षिप्त और कुशल बनाने की सुविधा देते हैं। आप किसी collection को iterate कर सकते हैं, और साथ ही Rust आपको फ़िल्टरिंग, मैपिंग, और अन्य तरीकों से डेटा को आसानी से बदलने की सुविधा देता है।

Iterators कैसे काम करते हैं? (How Do Iterators Work?)

Rust में, Iterator एक trait है, जो एक सटीक तरीके से डेटा के हर तत्व को रिटर्न करने की प्रक्रिया को परिभाषित करता है। Iterator trait में एक प्रमुख फ़ंक्शन होता है:

• next(): यह Iterator के अगले आइटम को रिटर्न करता है। यदि Iterator समाप्त हो जाता है, तो यह None रिटर्न करता है।

Syntax:

pub trait Iterator {
    type Item;

    fn next(&mut self) -> Option<Self::Item>;
}

इसमें next() फ़ंक्शन प्रत्येक आइटम को Option<T> प्रकार के रूप में रिटर्न करता है, जहाँ Some(T) का मतलब है कि एक नया आइटम प्राप्त हुआ है, और None का मतलब है कि Iterator समाप्त हो चुका है।

Iterator का उपयोग (Using Iterators)

आइए, एक साधारण उदाहरण देखें, जिसमें हम एक Vector पर Iterator का उपयोग कर रहे हैं।

fn main() {
    let numbers = vec![1, 2, 3];

    let mut iter = numbers.iter();  // Iterator बनाना

    // Iterator के प्रत्येक आइटम को next() के द्वारा एक्सेस करना
    println!("{:?}", iter.next());  // Some(1)
    println!("{:?}", iter.next());  // Some(2)
    println!("{:?}", iter.next());  // Some(3)
    println!("{:?}", iter.next());  // None (Iterator समाप्त हो चुका है)
}

इस उदाहरण में, हम next() का उपयोग करके Vector के प्रत्येक आइटम को एक-एक करके प्राप्त कर रहे हैं। जब सभी आइटम्स समाप्त हो जाते हैं, तो Iterator None रिटर्न करता है।

Iterator Methods (Iterator के प्रमुख Methods)

Rust में Iterators के साथ कई उपयोगी methods उपलब्ध हैं, जो आपको data को process और modify करने में मदद करते हैं। कुछ महत्वपूर्ण methods हैं:

1. iter(): यह method किसी collection का Iterator लौटाता है, जिससे आप उसके तत्वों पर traversal कर सकते हैं।
2. map(): यह method प्रत्येक आइटम पर एक फ़ंक्शन लागू करता है और एक नया Iterator रिटर्न करता है, जिसमें संशोधित तत्व होते हैं।

   fn main() {
       let numbers = vec![1, 2, 3];
       let doubled: Vec<i32> = numbers.iter().map(|x| x * 2).collect();
       println!("{:?}", doubled);  // [2, 4, 6]
   }
   

    

3. filter(): यह method केवल उन्हीं तत्वों को रिटर्न करता है, जो एक शर्त को पूरा करते हैं।

   fn main() {
       let numbers = vec![1, 2, 3, 4];
       let even_numbers: Vec<i32> = numbers.iter().filter(|&x| x % 2 == 0).collect();
       println!("{:?}", even_numbers);  // [2, 4]
   }
   

    

4. sum(): यह method Iterator के सभी आइटम्स का योग (sum) लौटाता है।

   fn main() {
       let numbers = vec![1, 2, 3];
       let total: i32 = numbers.iter().sum();
       println!("योग है: {}", total);  // 6
   }
   

    

5. collect(): यह method Iterator के आइटम्स को एक collection (जैसे Vector) में बदलने के लिए उपयोग किया जाता है।

   fn main() {
       let numbers = vec![1, 2, 3];
       let collected: Vec<i32> = numbers.iter().collect();
       println!("{:?}", collected);  // [1, 2, 3]
   }
   

    

Iterator का Ownership (Ownership with Iterators)

Rust में Iterators तीन प्रकार के ownership पर आधारित हो सकते हैं:

1. iter(): यह items के immutable references रिटर्न करता है।
2. iter_mut(): यह items के mutable references रिटर्न करता है, यानी आप आइटम्स को modify कर सकते हैं।
3. into_iter(): यह items का ownership रिटर्न करता है, यानी आइटम्स को move करता है।

उदाहरण (Ownership के साथ Iterator):

fn main() {
    let mut numbers = vec![1, 2, 3];

    for num in numbers.iter_mut() {
        *num += 10;
    }

    println!("{:?}", numbers);  // [11, 12, 13]
}

इस उदाहरण में, हमने iter_mut() का उपयोग किया, जिससे हम Vector के आइटम्स को modify कर सकते हैं।

Iterators का लाभ (Benefits of Using Iterators)

1. Lazy Evaluation: Iterators केवल तब ही calculation करते हैं जब उन्हें ज़रूरत होती है, जिससे memory और performance को बचाया जा सकता है।
2. Readable और Modular Code: Iterators के साथ chain methods (जैसे map, filter) का उपयोग करने से कोड अधिक पढ़ने योग्य और modular हो जाता है।
3. Functional Programming Style: Iterators Rust में functional programming की शक्ति को प्रदर्शित करते हैं, जहाँ आप डेटा को साफ़ और succinct तरीके से process कर सकते हैं।

Closures क्या हैं? (What are Closures?)

Rust में Closures छोटे और अनाम फ़ंक्शंस होते हैं, जिन्हें आप ऑन-द-फ्लाई (on-the-fly) परिभाषित कर सकते हैं और जो अपने आस-पास की स्कोप (scope) से वैल्यूज़ को कैप्चर कर सकते हैं। Closures को उन फ़ंक्शंस के रूप में समझा जा सकता है जो आप लिखते समय ही वैरिएबल्स और डेटा को कैप्चर करते हैं।

Closures आपको छोटे, reusable कोड ब्लॉक्स बनाने की सुविधा देते हैं जिन्हें आप अन्य फ़ंक्शंस की तरह पास कर सकते हैं, execute कर सकते हैं या स्टोर कर सकते हैं। Rust में Closures को अधिक लचीला बनाने के लिए, वे फ़ंक्शंस के साथ कंपैरेबल होते हैं, लेकिन उनके पास extra शक्तियाँ होती हैं, जैसे कि कैप्चरिंग और flexible type inference.

Closures का परिचय (Introduction to Closures)

Closures Rust में powerful abstraction हैं, जो सामान्य फ़ंक्शंस की तरह काम करते हैं, लेकिन उन्हें कुछ अतिरिक्त क्षमताएँ मिलती हैं:

1. Type Inference (प्रकार का अनुमान): आप Closure में types को निर्दिष्ट नहीं करते हैं। Rust स्वचालित रूप से types का अनुमान लगाता है।
2. Environment Capture (पर्यावरण कैप्चर): Closure कोड के बाहर के वैरिएबल्स को “कैप्चर” कर सकता है और उनका उपयोग कर सकता है।
3. Anonymous Functions (अनाम फ़ंक्शंस): Closure का कोई नाम नहीं होता है। इसे तुरंत उपयोग किया जाता है या किसी वैरिएबल में स्टोर किया जा सकता है।

Closure का सिंटैक्स (Syntax):

Closure को परिभाषित करने का सामान्य सिंटैक्स है:

let closure_name = |parameter_list| {
    // कोड ब्लॉक
};

Closure का उदाहरण (Example of Closure)

fn main() {
    let add = |a: i32, b: i32| a + b;  // Closure परिभाषित करना
    let result = add(5, 10);  // Closure को कॉल करना
    println!("परिणाम: {}", result);  // परिणाम: 15
}

इस उदाहरण में, हमने एक Closure add परिभाषित किया है, जो दो संख्याओं को जोड़ता है। Closure में types को निर्दिष्ट नहीं किया गया है, लेकिन Rust स्वचालित रूप से types का अनुमान लगाता है। जब हम Closure को कॉल करते हैं, तो यह हमें सही परिणाम लौटाता है।

Closures में Environment Capture (Environment Capture in Closures)

Closures की एक खासियत यह है कि वे अपने आसपास के स्कोप से वैरिएबल्स को “कैप्चर” कर सकते हैं। इसका मतलब है कि Closure के अंदर आप स्कोप में मौजूद वैरिएबल्स को access कर सकते हैं, बिना उन्हें फ़ंक्शन पैरामीटर्स के रूप में पास किए।

उदाहरण:

fn main() {
    let x = 5;
    let closure = |y: i32| x + y;  // Closure स्कोप से x को कैप्चर कर रहा है
    let result = closure(10);
    println!("परिणाम: {}", result);  // परिणाम: 15
}

यहाँ Closure x को उसके बाहर के स्कोप से कैप्चर कर रहा है। जब हम Closure को कॉल करते हैं, तो यह x + y का परिणाम लौटाता है।

Closures के तीन प्रकार (Three Types of Closures)

Rust में तीन प्रकार के Closures होते हैं, जो इस बात पर आधारित होते हैं कि वे environment से वैरिएबल्स को कैसे कैप्चर करते हैं:

1. Fn: जब Closure केवल वैरिएबल्स को पढ़ता है, यानी यह environment में वैरिएबल्स को सिर्फ borrow करता है।
2. FnMut: जब Closure वैरिएबल्स को modify करता है, यानी यह environment में वैरिएबल्स को mutable रूप से borrow करता है।
3. FnOnce: जब Closure environment में वैरिएबल्स को move करता है, यानी यह वैरिएबल्स की ownership को ले लेता है और एक बार execute होने के बाद इसे फिर से इस्तेमाल नहीं कर सकता।

Fn उदाहरण (Borrowing with Fn):

fn main() {
    let x = 10;
    let show = || println!("x का मान: {}", x);  // Fn क्लोजर
    show();  // x का उपयोग हुआ लेकिन modify नहीं किया गया
}

FnMut उदाहरण (Mutating with FnMut):

fn main() {
    let mut x = 10;
    let mut add_to_x = |y| x += y;  // FnMut क्लोजर
    add_to_x(5);
    println!("x का नया मान: {}", x);  // 15
}

FnOnce उदाहरण (Moving with FnOnce):

fn main() {
    let x = String::from("Hello");
    let consume_x = || println!("x का मान: {}", x);  // FnOnce क्लोजर
    consume_x();  // x move हो गया
    // consume_x();  // इसे दोबारा कॉल करने से एरर होगा, क्योंकि x move हो गया है
}

Closures के उपयोग (Uses of Closures)

1. Callbacks (कॉलबैक्स):
   • Closures का उपयोग अक्सर callbacks के रूप में किया जाता है, जहाँ आप किसी फ़ंक्शन को Closure के रूप में कोड का एक ब्लॉक पास करते हैं, जिसे बाद में execute किया जा सकता है।

     fn perform_action<F>(action: F)
     where
         F: Fn(),
     {
         action();
     }
     
     fn main() {
         perform_action(|| println!("यह एक क्लोजर है!"));
     }
     

      

2. Functional Programming (फ़ंक्शनल प्रोग्रामिंग):
   • Closures का उपयोग functional programming पैटर्न जैसे कि map, filter, और reduce के साथ किया जाता है, जहाँ आप डेटा के साथ फ़ंक्शंस को पास करते हैं और manipulate करते हैं।

     fn main() {
         let numbers = vec![1, 2, 3];
         let doubled: Vec<i32> = numbers.iter().map(|x| x * 2).collect();
         println!("{:?}", doubled);  // [2, 4, 6]
     }
     

      

3. Environment Capture (पर्यावरण कैप्चर):
   • Closures कोड के बाहरी स्कोप से वैरिएबल्स को कैप्चर करके उनके साथ काम कर सकते हैं, जिससे वे सामान्य फ़ंक्शंस की तुलना में अधिक लचीले हो जाते हैं।

Closures और फ़ंक्शंस में अंतर (Differences Between Closures and Functions)

1. Type Inference (प्रकार का अनुमान):
   • Closures में types को निर्दिष्ट करना आवश्यक नहीं होता। Rust स्वचालित रूप से types का अनुमान लगाता है। जबकि फ़ंक्शंस में आप प्रकारों को स्पष्ट रूप से निर्दिष्ट करते हैं।
2. Environment Capture (पर्यावरण कैप्चर):
   • Closures environment में मौजूद वैरिएबल्स को कैप्चर कर सकते हैं, जबकि फ़ंक्शंस केवल उन्हीं वैरिएबल्स के साथ काम कर सकते हैं, जो पैरामीटर्स के रूप में पास किए गए हों।
3. Anonymous Functions (अनाम फ़ंक्शंस):
   • Closures अनाम होते हैं और इन्हें तुरंत परिभाषित और उपयोग किया जा सकता है, जबकि फ़ंक्शंस का नाम होता है और वे एक स्पष्ट संरचना का पालन करते हैं।

Functional Programming की अवधारणाएँ (Functional Programming Concepts in Rust)

Rust एक systems programming भाषा होते हुए भी Functional Programming की अवधारणाओं का समर्थन करता है। Functional Programming (FP) एक प्रोग्रामिंग शैली है, जिसमें फ़ंक्शंस को प्राथमिक इकाई के रूप में माना जाता है, और ये फ़ंक्शंस डेटा को सीधे बदलने के बजाय नए डेटा को रिटर्न करते हैं। Rust में, आप Functional Programming की शक्तिशाली अवधारणाओं जैसे कि immutable data, higher-order functions, closures, और iterators का उपयोग करके कोड को अधिक संक्षिप्त, पुन: उपयोगी, और सुरक्षित बना सकते हैं।

Functional Programming के प्रमुख सिद्धांत (Key Concepts of Functional Programming)

1. Immutability (अपरिवर्तनीयता):
   • Functional Programming में डेटा को immutable (अपरिवर्तनीय) माना जाता है। इसका मतलब है कि एक बार किसी वैल्यू को असाइन कर दिया गया है, तो उसे बदला नहीं जा सकता।
   • Rust में वैरिएबल्स को let कीवर्ड के साथ अपरिवर्तनीय रूप से परिभाषित किया जाता है, जिससे डेटा का unintended mutation (अनपेक्षित परिवर्तन) नहीं हो सकता।

     fn main() {
         let x = 10;
         // x = 20;  // यह कोड काम नहीं करेगा क्योंकि x अपरिवर्तनीय है
         println!("{}", x);
     }
     

      

2. Pure Functions (शुद्ध फ़ंक्शंस):
   • एक pure function वह होता है, जो केवल अपने इनपुट्स पर आधारित होता है और कोई side effects उत्पन्न नहीं करता है। इसका मतलब है कि फ़ंक्शन का आउटपुट हमेशा इनपुट पर निर्भर करता है और यह बाहरी state को नहीं बदलता।
   • Pure functions आसानी से परीक्षण योग्य (testable) होते हैं और उन्हें समझना आसान होता है।

     fn add(a: i32, b: i32) -> i32 {
         a + b  // यह एक शुद्ध फ़ंक्शन है, क्योंकि इसका आउटपुट इनपुट पर ही निर्भर करता है
     }
     
     fn main() {
         let result = add(5, 10);
         println!("{}", result);
     }
     

      

3. First-Class and Higher-Order Functions:
   • Functional Programming में, फ़ंक्शंस को first-class citizens माना जाता है, यानी आप फ़ंक्शंस को वैरिएबल्स की तरह स्टोर, पास, और रिटर्न कर सकते हैं।
   • Higher-Order Functions वे फ़ंक्शंस होते हैं, जो अन्य फ़ंक्शंस को पैरामीटर के रूप में लेते हैं या फ़ंक्शंस को रिटर्न करते हैं।

     fn apply_twice<F>(f: F, x: i32) -> i32
     where
         F: Fn(i32) -> i32,  // Higher-order function जो एक फ़ंक्शन को पैरामीटर के रूप में लेता है
     {
         f(x) + f(x)
     }
     
     fn main() {
         let square = |x| x * x;
         let result = apply_twice(square, 5);
         println!("{}", result);  // 50, क्योंकि 5*5 + 5*5 = 25 + 25
     }
     

      

4. Closures (क्लोज़र्स):
   • Closures अनाम फ़ंक्शंस होते हैं, जो अपने आसपास के स्कोप से वैरिएबल्स को कैप्चर कर सकते हैं। ये फ़ंक्शनल प्रोग्रामिंग में बहुत काम आते हैं, खासकर जब आप data transformation जैसे कार्य कर रहे हों।
   • Closures Rust में data manipulation और functional programming के दृष्टिकोण से अत्यधिक उपयोगी होते हैं।

     fn main() {
         let add = |a, b| a + b;  // Closure
         println!("{}", add(2, 3));  // 5
     }
     

      

5. Composition (रचना):
   • Functional Programming में, बड़े फ़ंक्शंस को छोटे-छोटे, पुन: उपयोगी फ़ंक्शंस में विभाजित किया जाता है, जिन्हें आसानी से एक साथ जोड़कर (compose) बड़े कार्य किए जा सकते हैं।
   • यह modular code लिखने में मदद करता है, जहाँ प्रत्येक फ़ंक्शन एक छोटा, स्पष्ट कार्य करता है।

     fn add_one(x: i32) -> i32 {
         x + 1
     }
     
     fn square(x: i32) -> i32 {
         x * x
     }
     
     fn main() {
         let result = add_one(square(5));
         println!("{}", result);  // 26, क्योंकि (5^2) + 1 = 25 + 1
     }
     

      

6. Iterators (इटरेटर्स):
   • Rust में इटरेटर्स का उपयोग functional programming पैटर्न को अपनाने में किया जाता है। इटरेटर्स डेटा संरचनाओं के तत्वों को एक-एक करके प्रोसेस करते हैं, और उनके साथ फ़िल्टर, मैप, और अन्य higher-order फ़ंक्शंस का उपयोग किया जा सकता है।
   • इटरेटर्स lazy होते हैं, यानी जब तक उन्हें specifically execute नहीं किया जाता, वे computation को नहीं चलाते।

     fn main() {
         let numbers = vec![1, 2, 3, 4];
         let squared: Vec<i32> = numbers.iter().map(|x| x * x).collect();  // Functional transformation using iterators
         println!("{:?}", squared);  // [1, 4, 9, 16]
     }
     

      

7. Pattern Matching (पैटर्न मैचिंग):
   • Rust का Pattern Matching Functional Programming का एक शक्तिशाली टूल है। इसका उपयोग आप डेटा को संरचित करने और विभिन्न वैरिएंट्स के आधार पर कार्य करने के लिए कर सकते हैं।
   • Pattern Matching Rust में enums और complex data types के साथ काम करने का एक महत्वपूर्ण तरीका है।

     enum Result {
         Success(i32),
         Failure(String),
     }
     
     fn main() {
         let outcome = Result::Success(10);
     
         match outcome {
             Result::Success(val) => println!("सफलता, मान: {}", val),
             Result::Failure(err) => println!("त्रुटि: {}", err),
         }
     }
     

      

Functional Programming का लाभ (Benefits of Functional Programming)

1. Readable और Modular Code:
   • FP में छोटे-छोटे, स्वतंत्र फ़ंक्शंस बनाए जाते हैं, जो एक विशिष्ट कार्य करते हैं। इससे कोड अधिक पठनीय और modular बनता है।
2. Immutability और Thread-Safety:
   • Immutability पर आधारित होने के कारण, FP कोड thread-safe होता है, क्योंकि immutable डेटा race conditions या unexpected changes से सुरक्षित होता है।
3. Easier Testing:
   • Functional Programming में शुद्ध फ़ंक्शंस (pure functions) होने के कारण, यूनिट टेस्टिंग करना सरल होता है, क्योंकि हर बार दिए गए इनपुट पर आउटपुट एक ही रहेगा।
4. Reusability:
   • Higher-order functions और closures के कारण, फ़ंक्शंस को आसानी से पुनः उपयोग किया जा सकता है और नए कार्यों में सम्मिलित किया जा सकता है।

Functional Programming की सीमाएँ (Limitations of Functional Programming)

1. Performance Overhead:
   • कभी-कभी FP के कुछ सिद्धांत जैसे immutability के कारण अतिरिक्त कंप्यूटेशन हो सकते हैं, जो प्रदर्शन (performance) को प्रभावित कर सकते हैं।
2. Complexity in Certain Tasks:
   • Functional Programming कुछ कार्यों में अधिक जटिल हो सकती है, जैसे mutable state को manage करना, क्योंकि FP मुख्यतः immutability पर आधारित होती है।