rust-course/compiler/fight-with-compiler/lifetime/loop

[giscus[bot]]

compiler/fight-with-compiler/lifetime/loop

https://course.rs/compiler/fight-with-compiler/lifetime/loop.html

[dijiekstra]

👍🏻 first,
📖 second

[apodemakeles]

“唯一满足条件的就是：k的生命周期等于循环生命周期。”
一个被函数返回的借用的生命周期与函数内的一个循环的生命周期等价？编译器再傻也不会这么认为吧

[sopaco]

use rand::{thread_rng, Rng};

#[derive(Debug, PartialEq)]
enum Tile {
    Empty,
}

fn random_empty_tile(arr: &[Tile]) -> &Tile {
    loop {
        let l = arr.len();
        let i = thread_rng().gen_range(0..1);
        let tile = &arr[i];
        if &Tile::Empty == tile {
            return &tile;
        }
    }
}

[SUN-LG]

但是我们的two方法在循环中对k进行了提前返回，编译器自然会认为存在其它代码，这会导致k的生命周期小于循环的生命周期。

对这句话存有疑问，编译器并不会认为k的生命周期小于循环吧。

loop {
                // let k = self.one();
                let k = &1;
                if *k > 10i32 {
                    return k;
                }
    
                // 可能存在的剩余代码
                // ...

                println!("{}", k);
            }

return 后 k 可以继续使用。

[guopenghui]

实际上k的生命周期是要超过函数的。设计了一个例子：

fn foo(x: &mut i32) -> &i32 {
    x
}

fn bar<'a>(x: &'a mut i32) -> &'a i32 {  // 输入值生命周期 >= 返回值生命周期 > 函数生命周期
    let a = 0;
    {
        let x_ref = foo(x);  // 这里调用foo，产生了一个对 *x 的借用 x_ref
        if a < 0 {
            return x_ref;  // x_ref是返回值，因此其生命周期 > 函数生命周期
        }
    }
    *x = 2;  // 这里会报错。因为x_ref生命周期是超过整个函数的，
             // x_ref是对*x的借用，所以这里x不能修改*x
    &3
}
这么说可能有点奇怪，x_ref超出作用域已经不在了，但x_ref保存的那个引用仍然存在(该引用的生命周期超过整个函数）

有点类似于再借用(reborrow)：

let a = &mut x;
let b = &*a;
*a += 1;  // 报错，因为b的生命周期超过了a，已经存在b的情况下不允许使用a
println("{}", b)

文中的例子为什么不能编译，我觉得就是因为title作为返回值，导致其生命周期没有在循环内结束，而是超过了整个函数。而return语句在一个if块内，编译器无法判断到这里函数会不会返回。如果没有返回，则下一次循环中title仍然存在，而又arr.len()尝试获取一个不可变引用，因此就报错了。下面修改后的例子中不作判断直接返回，编译器应该能认出来不会有一下次循环，所以能通过。

[VhRvo]

这个例子和 niko's NLL 这篇的第三个例子有点像。

[Buer-Nahida]

这种中间变量的错误我在线程间传递*mut T时也遇到过
我为了传递*mut T写了一个RawMutPtr<T>元组结构体，里面包含一个*mut T，给它实现了Send和Sync两个trait
然后传递RawMutPtr<T>结构体

        thread::spawn(move || {
            for notes in STEP2_NOTES2 {
                for notes in notes.iter() {
                    for note in notes {
                        println!("{:?}", *note as u8);
                        play_note(unsafe { ptr_clone.0.as_mut().unwrap() }, *note as u8, 1);
                    }
                }
            }
        }),

看似没问题，结果

error[E0277]: `*mut MidiOutputConnection` cannot be sent between threads safely
   --> src/play.rs:78:23
    |
78  |           thread::spawn(move || {
    |           ------------- ^------
    |           |             |
    |  _________|_____________within this `{closure@src/play.rs:78:23: 78:30}`
    | |         |
    | |         required by a bound introduced by this call
79  | |             for notes in STEP2_NOTES2 {
80  | |                 for notes in notes.iter() {
81  | |                     for note in notes {
...   |
86  | |             }
87  | |         }),
    | |_________^ `*mut MidiOutputConnection` cannot be sent between threads safely
    |
    = help: within `{closure@src/play.rs:78:23: 78:30}`, the trait `Send` is not implemented for `*mut MidiOutputConnection`
note: required because it's used within this closure
   --> src/play.rs:78:23
    |
78  |         thread::spawn(move || {
    |                       ^^^^^^^
note: required by a bound in `spawn`
   --> /home/star/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/thread/mod.rs:685:8
    |
682 | pub fn spawn<F, T>(f: F) -> JoinHandle<T>
    |        ----- required by a bound in this function
...
685 |     F: Send + 'static,
    |        ^^^^ required by this bound in `spawn`

For more information about this error, try `rustc --explain E0277`.

然后只需要引入中间变量temp:

        thread::spawn(move || {
            let temp = ptr_clone;
            for notes in STEP2_NOTES2 {
                for notes in notes.iter() {
                    for note in notes {
                        println!("{:?}", *note as u8);
                        play_note(unsafe { temp.0.as_mut().unwrap() }, *note as u8, 1);
                    }
                }
            }
        }),

    Checking midi_play v0.1.0 (/code/star/midi_play)
    Finished dev [unoptimized + debuginfo] target(s) in 0.10s

就通过了

[AnkoGo123]

"如果一个引用值从函数的某个路径提前返回了，那么该借用必须要在函数的所有返回路径都合法"这句话才是经典

[Hobr]

Polonius已经在Rust nightly默认启动并且计划在年内进stable了!