Rust में कार्यात्मक प्रोग्रामिंग: A से Z तक

Rust में कार्यात्मक प्रोग्रामिंग: A से Z तक

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

1. मूल बातें: इम्यूटेबिलिटी और चर

कार्यात्मक प्रोग्रामिंग इम्यूटेबिलिटी (अपरिवर्तनीयता) से शुरू होती है। Rust में, चर डिफ़ॉल्ट रूप से अपरिवर्तनीय होते हैं। यह कई भाषाओं से एक महत्वपूर्ण अंतर है।

// इम्यूटेबल चर (डिफ़ॉल्ट रूप से)\nlet x = 10;\n// x = 20; // संकलन त्रुटि!\n\n// म्यूटेबल चर (स्पष्ट रूप से)\nlet mut y = 5;\ny = 15; // काम करता है

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

2. क्लोजर (Closures) — अनाम फ़ंक्शन

क्लोजर अनाम फ़ंक्शन होते हैं जो अपने वातावरण से चर कैप्चर कर सकते हैं। Rust में, वे Fn, FnMut और FnOnce ट्रेट्स के माध्यम से कार्यान्वित किए जाते हैं।

2.1. सिंटैक्स और चर कैप्चर करना

// सरल क्लोजर\nlet add_one = |x: i32| -> i32 { x + 1 };\nprintln!("{}", add_one(5)); // 6\n\n// वातावरण से चर कैप्चर करना\nlet base = 10;\nlet add_base = |x| x + base; // base को संदर्भ (&) द्वारा कैप्चर किया गया\nprintln!("{}", add_base(20)); // 30\n\n// म्यूटेशन के साथ कैप्चर (FnMut)\nlet mut counter = 0;\nlet mut increment = || { counter += 1; };\nincrement();\nincrement();\nprintln!("{}", counter); // 2\n\n// उपभोग के साथ कैप्चर (FnOnce)\nlet name = String::from("Rust");\nlet consume = || { drop(name); };\nconsume();\n// println!("{}", name); // त्रुटि: name स्थानांतरित हो गया

2.2. फ़ंक्शन तर्क के रूप में क्लोजर

क्लोजर अक्सर उच्च-क्रम फ़ंक्शन जैसे map, filter और fold में पास किए जाते हैं।

let numbers = vec![1, 2, 3, 4, 5];\n\n// filter के साथ क्लोजर का उपयोग\nlet evens: Vec<i32> = numbers\n    .into_iter()\n    .filter(|&x| x % 2 == 0)\n    .collect();\n\nprintln!("{:?}", evens); // [2, 4]

3. इटरेटर और रूपांतरण श्रृंखलाएँ

इटरेटर Rust में कार्यात्मक प्रोग्रामिंग का हृदय हैं। वे आलसी होते हैं (गणना केवल collect() या for कॉल करने पर होती है) और रूपांतरणों की श्रृंखला बनाने की अनुमति देते हैं।

3.1. बुनियादी इटरेटर एडेप्टर

let data = vec![1, 2, 3, 4, 5, 6];\n\n// श्रृंखला: filter -> map -> take -> collect\nlet result: Vec<i32> = data\n    .iter()\n    .filter(|&x| x % 2 == 0)  // सम संख्याएँ छोड़ें\n    .map(|x| x * 2)           // दोगुना करें\n    .take(2)                  // पहले दो लें\n    .collect();\n\nprintln!("{:?}", result); // [4, 8]

3.2. फोल्ड (fold) और रिडक्शन

fold अन्य भाषाओं में reduce के समान है। यह सभी तत्वों पर जाकर परिणाम संचित करता है।

let numbers = [1, 2, 3, 4, 5];\n\n// सभी संख्याओं का योग\nlet sum = numbers.iter().fold(0, |acc, &x| acc + x);\nprintln!("Sum: {}", sum); // 15\n\n// फैक्टोरियल\nlet factorial = (1..=5).fold(1, |acc, x| acc * x);\nprintln!("5! = {}", factorial); // 120

3.3. आलसी अनंत इटरेटर

// अनंत इटरेटर, पहले 10 लें\nlet first_ten: Vec<i32> = (0..)\n    .filter(|x| x % 2 == 0)\n    .map(|x| x * x)