Rust में कार्यात्मक प्रोग्रामिंग: मुहावरे और अभ्यास

Rust में कार्यात्मक प्रोग्रामिंग: इटरेटर से मोनाड तक

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

क्लोजर (closures) और लैम्ब्डा एक्सप्रेशन

Rust में क्लोजर अनाम फ़ंक्शन होते हैं जो आसपास के दायरे से वेरिएबल कैप्चर कर सकते हैं। वे कार्यात्मक दृष्टिकोण की नींव हैं, जो व्यवहार को डेटा के रूप में पास करने की अनुमति देते हैं।

क्लोजर का सिंटैक्स संक्षिप्त है: |पैरामीटर| बॉडी। क्लोजर को फ़ंक्शन में पास किया जा सकता है, वेरिएबल में संग्रहीत किया जा सकता है और फ़ंक्शन से वापस किया जा सकता है। कैप्चर को नियंत्रित करने वाले तीन ट्रेट्स को याद रखना महत्वपूर्ण है: Fn (उधार लेना), FnMut (परिवर्तनीय उधार लेना) और FnOnce (उपभोग करना)।

fn main() {
    // सरल क्लोजर
    let add_one = |x: i32| x + 1;
    println!("{}", add_one(5)); // 6

    // वेरिएबल कैप्चर करना
    let factor = 10;
    let multiply = |x| x * factor;
    println!("{}", multiply(3)); // 30

    // FnOnce ट्रेट के साथ क्लोजर
    let name = String::from("Rust");
    let greet = move || {
        println!("नमस्ते, {}!", name); // name को स्थानांतरित किया गया
    };
    greet();
    // println!("{}", name); // त्रुटि! name अब उपलब्ध नहीं है
}

move कीवर्ड मान द्वारा कैप्चर (स्थानांतरण) को बाध्य करता है, जो अक्सर मल्टीथ्रेडिंग के साथ काम करते समय या क्लोजर को किसी अन्य संदर्भ में पास करते समय आवश्यक होता है।

इटरेटर: आलसी प्रसंस्करण और मेथड चेन

Rust में कार्यात्मक शैली की सबसे मजबूत विशेषताओं में से एक शक्तिशाली इटरेटर एडेप्टर है। स्पष्ट for लूप और वेरिएबल म्यूटेशन के बजाय, आप मेथड चेन का उपयोग करते हैं: map, filter, fold, collect और अन्य। Rust में इटरेटर आलसी होते हैं - वे तब तक गणना नहीं करते जब तक कि कोई उपभोग करने वाली विधि (जैसे 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 के साथ योग (रिडक्शन)
    let sum = numbers.iter().fold(0, |acc, x| acc + x);
    println!("योग: {}", sum); // 21

    // any और all के साथ शर्त की जाँच
    let has_even = numbers.iter().any(|x| x % 2 == 0);
    println!("सम संख्याएँ हैं: {}", has_even); // true
}

इटरेटर का उपयोग कोड को घोषणात्मक, पठनीय और इंडेक्सिंग तथा ऐरे सीमाओं से संबंधित त्रुटियों के प्रति कम संवेदनशील बनाता है। Rust कंपाइलर अक्सर इटरेटर चेन को मैन्युअल लूप के बराबर कुशल मशीन कोड में अनुकूलित करता है।

पैटर्न मैचिंग और डिस्ट्रक्चरिंग

पैटर्न मैचिंग (match) Rust में कार्यात्मक प्रवाह नियंत्रण का हृदय है। यह डेटा के सभी संभावित वेरिएंट को सुरक्षित रूप से संभालने की अनुमति देता है, विशेष रूप से बीजगणितीय डेटा प्रकारों (enum) के संयोजन में। पैटर्न नेस्टेड हो सकते हैं, शर्तें (guards) शामिल कर सकते हैं, और स्ट्रक्चर, टुपल्स और एनम को डिस्ट्रक्चर कर सकते हैं।

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn handle_```