Rust
जीवन काल

वाक्य - विन्यास

• fn फ़ंक्शन <'a> (x: &' a प्रकार)
• संरचना संरचना <'a> {x: &' a प्रकार}
• enum Enum <'a> {वेरिएंट (&' a टाइप)}
• impl <'a> संरचना <' a> {fn x <'a ((self) -> &' a type {selfx .x}}
• impl <'a> Trait <' a> for Type
• impl <'a> प्रकार के लिए विशेषता <' a>
• fn function<F>(f: F) where for<'a> F: FnOnce(&'a Type)
• struct Struct<F> where for<'a> F: FnOnce(&'a Type) { x: F }
• enum Enum<F> where for<'a> F: FnOnce(&'a Type) { Variant(F) }
• impl<F> Struct<F> where for<'a> F: FnOnce(&'a Type) { fn x(&self) -> &F { &self.x } }

टिप्पणियों

फंक्शन पैरामीटर (इनपुट लाइफटाइम)

fn foo<'a>(x: &'a u32) {
    // ...
}

यह निर्दिष्ट करता है कि foo का जीवनकाल 'a , और पैरामीटर x जीवनकाल कम से कम 'a होना चाहिए। समारोह जीवनकाल आमतौर पर जीवनकाल के माध्यम से छोड़ा जाता है:

fn foo(x: &u32) {
    // ...
}

इस मामले में कि एक फ़ंक्शन कई संदर्भों को मापदंडों के रूप में लेता है और एक संदर्भ देता है, संकलक जीवनकाल एलिज़न के माध्यम से परिणाम के जीवनकाल का अनुमान नहीं लगा सकता है।

error[E0106]: missing lifetime specifier
1 | fn foo(bar: &str, baz: &str) -> &i32 {
  |                                 ^ expected lifetime parameter

इसके बजाय, आजीवन मापदंडों को स्पष्ट रूप से निर्दिष्ट किया जाना चाहिए।

// Return value of `foo` is valid as long as `bar` and `baz` are alive.
fn foo<'a>(bar: &'a str, baz: &'a str) -> &'a i32 {

फ़ंक्शंस कई आजीवन मापदंडों को भी ले सकते हैं।

// Return value is valid for the scope of `bar`
fn foo<'a, 'b>(bar: &'a str, baz: &'b str) -> &'a i32 {

संरचना क्षेत्र

struct Struct<'a> {
    x: &'a u32,
}

यह निर्दिष्ट करता है के किसी भी उदाहरण है कि Struct जीवन है 'a , और &u32 में संग्रहीत x के कम से कम एक जीवन भर होना आवश्यक है 'a ।

Impl ब्लॉक

impl<'a> Type<'a> {
    fn my_function(&self) -> &'a u32 {
        self.x
    }
}

यह निर्दिष्ट करता है कि Type का जीवनकाल 'a , और यह कि my_function() द्वारा लौटाया गया संदर्भ अब 'a समाप्त होने के बाद वैध नहीं हो सकता है क्योंकि Type अब self.x रखने के लिए मौजूद नहीं है।

उच्च श्रेणी के विशेषता सीमाएँ

fn copy_if<F>(slice: &[i32], pred: F) -> Vec<i32>
    where for<'a> F: Fn(&'a i32) -> bool
{
    let mut result = vec![];
    for &element in slice {
        if pred(&element) {
            result.push(element);
        }
    }
    result
}

यह निर्दिष्ट करता है कि Fn विशेषता सीमा में i32 के संदर्भ में कोई भी जीवनकाल हो सकता है।

निम्नलिखित काम नहीं करता है:

fn wrong_copy_if<'a, F>(slice: &[i32], pred: F) -> Vec<i32>
    where F: Fn(&'a i32) -> bool
{                                   // <----------------+
    let mut result = vec![];        //       'a scope   |
    for &element in slice {         // <--------+       |
        if pred(&element) {         //          |       |
            result.push(element);   // element's|       |
        }                           //   scope  |       |
    }                               // <--------+       |
    result                          //                  |
}                                   // <----------------+

संकलक निम्नलिखित त्रुटि देता है:

error: `element` does not live long enough
if pred(&element) {         //          |       |
         ^~~~~~~

क्योंकि element स्थानीय चर 'a जीवन भर (जब तक हम कोड की टिप्पणियों से देख सकते हैं) तक नहीं रहते हैं।

जीवनकाल को कार्य स्तर पर घोषित नहीं किया जा सकता है, क्योंकि हमें दूसरे जीवनकाल की आवश्यकता है। इसलिए हमने for<'a> उपयोग किया है: यह निर्दिष्ट करने के लिए कि संदर्भ किसी भी जीवनकाल के लिए मान्य हो सकता है (इसलिए छोटे जीवनकाल का उपयोग किया जा सकता है)।

उच्च-रैंक विशेषता सीमा का उपयोग संरचनाओं पर भी किया जा सकता है:

struct Window<F>
    where for<'a> F: FnOnce(&'a Window<F>)
{
    on_close: F,
}

साथ ही अन्य वस्तुओं पर भी।

उच्च-रैंक विशेषता सीमाएँ Fn* लक्षणों के साथ सबसे अधिक उपयोग की जाती हैं।

इन उदाहरणों के लिए, जीवनकाल एलिज़न ठीक काम करता है इसलिए हमें जीवनकाल निर्दिष्ट करने की आवश्यकता नहीं है।