Rust में कार्यात्मक प्रोग्रामिंग: दृष्टिकोण और उदाहरण

Rust में कार्यात्मक प्रोग्रामिंग का परिचय

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

कार्यात्मक दृष्टिकोण के मूल सिद्धांत: अपरिवर्तनीयता और शुद्ध फलन

कार्यात्मक प्रोग्रामिंग दो स्तंभों पर आधारित है: डेटा की अपरिवर्तनीयता और शुद्ध फलन। Rust अपरिवर्तनीयता को प्रोत्साहित करता है — डिफ़ॉल्ट रूप से सभी चर अपरिवर्तनीय होते हैं। मान बदलने के लिए, आपको स्पष्ट रूप से mut निर्दिष्ट करना होगा।

fn main() {    let x = 5; // अपरिवर्तनीय चर    // x = 6; // संकलन त्रुटि    let mut y = 10;    y += 5; // अनुमति है, क्योंकि y परिवर्तनीय है    println!("x = {}, y = {}", x, y);}

एक शुद्ध फलन का कोई दुष्प्रभाव नहीं होता है और यह समान तर्कों के लिए हमेशा एक ही परिणाम लौटाता है। Rust आपको ऐसे फलन लिखने की अनुमति देता है, लेकिन ऐसा करने के लिए बाध्य नहीं करता — आप स्वतंत्र रूप से शैलियों को मिला सकते हैं।

fn add(a: i32, b: i32) -> i32 {    a + b // शुद्ध फलन}

क्लोजर (closures) — अनाम फलन

Rust में क्लोजर अनाम फलन हैं जो आसपास के दायरे से चर कैप्चर कर सकते हैं। वे सिंटैक्स |पैरामीटर| बॉडी का उपयोग करके परिभाषित किए जाते हैं। कैप्चर के तरीके के आधार पर तीन प्रकार के क्लोजर होते हैं: संदर्भ द्वारा (&T), परिवर्तनीय संदर्भ द्वारा (&mut T) और मान द्वारा (T)।

क्लोजर का सरल उदाहरण

fn main() {    let factor = 2;    let multiply = |x: i32| x * factor;    println!("{}", multiply(10)); // 20}

परिवर्तनीय कैप्चर के साथ क्लोजर

fn main() {    let mut counter = 0;    let mut increment = || {        counter += 1;        counter    };    println!("{}", increment()); // 1    println!("{}", increment()); // 2}

क्लोजर का व्यापक रूप से इटरेटर के साथ और उच्च-क्रम फलनों में व्यवहार पारित करने के लिए उपयोग किया जाता है।

इटरेटर और कार्यात्मक श्रृंखलाएँ

Rust में इटरेटर सबसे शक्तिशाली कार्यात्मक अमूर्तताओं में से एक हैं। लूप के बजाय, आप map, filter, fold और अन्य विधियों की श्रृंखलाएँ बना सकते हैं। इटरेटर आलसी होते हैं — गणना केवल तब होती है जब कोई उपभोक्ता (जैसे collect या for_each) कॉल किया जाता है।

उदाहरण: फ़िल्टरिंग और रूपांतरण

fn main() {    let numbers = vec![1, 2, 3, 4, 5, 6];    let result: Vec<i32> = numbers        .iter()        .filter(|&x| x % 2 == 0) // सम संख्याएँ रखें        .map(|x| x * x)          // वर्ग करें        .collect();    println!("{:?}", result); // [4, 16, 36]}

फोल्ड (fold) — मानों का संचय

fn main() {    let numbers = vec![1, 2, 3, 4];    let sum = numbers.iter().fold(0, |acc, x| acc + x);    println!("योग: {}", sum); // 10}

इटरेटर कोड को घोषणात्मक बनाते हैं: आप वर्णन करते हैं कि क्या करने की आवश्यकता है, न कि कैसे। इससे त्रुटियों की संभावना कम होती है और पठनीयता में सुधार होता है।

पैटर्न मैचिंग (pattern matching)

match निर्माण Rust में कार्यात्मक शैली का एक केंद्रीय तत्व है। यह जटिल डेटा संरचनाओं को पार्स करने, Option और Result वेरिएंट को संभालने और व्यापक जाँच लिखने की अनुमति देता है।

मूल उदाहरण

fn describe_number(n: i32) -> &'static str {    match n {        0 => "शून्य",        1 | 2 => "छोटी संख्या",        3..=10 => "मध्यम संख्या",        _ if n < 0 => "ऋणात्मक",\