Rust
일생

통사론

• fn 함수 <a> (x : & 'a Type)
• struct Struct < 'a> {x : &'a Type}
• enum Enum < 'a> {변형 (& a a Type)}
• impl < 'a> Struct <'a> {fn x < 'a (self) -> &'a {self.x} 유형}
• impl < 'a> 유형에 대한 특성 <'a>
• 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 이어야 함을 지정 'a . 기능 수명은 일반적으로 평생 elision을 통해 생략됩니다.

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 , x 저장된 &u32 가 적어도 a의 수명을 가져야한다는 것을 지정 '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 평생 'a 만큼 길지 않기 때문입니다 (코드의 주석에서 볼 수 있듯이).

수명은 기능 수준에서 선언 할 수 없습니다. 다른 평생을 필요로하기 때문입니다. 그것이 for<'a> 사용 된 이유입니다. 참조가 모든 평생 동안 유효 할 수 있음을 지정하기 때문에 (따라서 더 작은 수명을 사용할 수 있습니다).

상위 순위 특성 경계는 구조체에도 사용할 수 있습니다.

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

뿐만 아니라 다른 항목.

Higher-Rank 특성 경계는 Fn* 특성과 함께 가장 일반적으로 사용됩니다.

이 예제의 경우 수명 측정이 정상적으로 작동하므로 수명을 지정할 필요가 없습니다.