Rust
livstid

Syntax

• fn-funktion <'a> (x: &' a Type)
• struct Struct <'a> {x: &' a Type}
• enum Enum <'a> {Variant (&' a Type)}
• impl <'a> Struktur <' a> {fn x <'a> (& self) -> &' a Type {self.x}}
• impl <'a> Egenskap <' a> för typ
• impl <'a> Egenskap för typ <' 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 } }

Anmärkningar

Funktionsparametrar (inmatningstider)

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

Detta anger att foo har livslängd 'a , och parametern x måste ha en livslängd på minst 'a . Funktionslivslängder utelämnas vanligtvis genom livslängd :

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

I det fall att en funktion tar flera referenser som parametrar och returnerar en referens, kan kompilatorn inte dra slutsatsen om resultat genom livslängd .

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

Istället bör livstidsparametrarna uttryckligen anges.

// 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 {

Funktioner kan också ta flera livstidsparametrar.

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

Strukturfält

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

Detta specificerar att varje given instans av Struct har livslängd 'a , och &u32 lagrad i x måste ha en livslängd på minst 'a .

Implementera block

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

Detta specificerar att Type har livstid 'a , och att referensen som returneras av my_function() kanske inte längre är giltig efter 'a slutar eftersom Type inte längre finns för att hålla self.x

Högre rankningsegenskaper

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
}

Detta specificerar att referensen på i32 i Fn kan ha vilken livstid som helst.

Följande fungerar inte:

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                          //                  |
}                                   // <----------------+

Kompilatorn ger följande fel:

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

eftersom element lokal variabel inte lever så länge som 'a livstid" (som vi kan se av kodens kommentarer).

Livstiden kan inte deklareras på funktionsnivå, eftersom vi behöver en annan livstid. Det är därför vi använde for<'a> : för att specificera att referensen kan vara giltig för alla livslängder (följaktligen kan en mindre livslängd användas).

Högre rankningsegenskaper kan också användas på strukturer:

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

såväl som på andra artiklar.

Högre rankningsegenskaper används oftast med Fn* .

För dessa exempel fungerar livslängden bra så vi behöver inte ange livslängden.