advance/lifetime/advance

[sunface]

https://course.rs/advance/lifetime/advance.html

[melertoyyang]

这章的爬坡陡度太高了，可能是基础知识还是没掌握

[Nanbert]

或者这么理解是否合理呢？&mut foo在let那里就结束它的作用域了，所以‘a就是那一句话的范围，但后面loan却在println那里又出现了，超过了该范围...，（由输入生命周期推导出输出生命周期，然后判断实际函数使用中是否符合输出生命周期）

[Kangaxx-0]

或者这么理解是否合理呢？&mut foo在let那里就结束它的作用域了，所以‘a就是那一句话的范围，但后面loan却在println那里又出现了，超过了该范围...，（由输入生命周期推导出输出生命周期，然后判断实际函数使用中是否符合输出生命周期）

事实上并没有，foo 在loan绑定后，才call了method share, 这也是为什么borrow checker会返回编译问题。

如果你微调这个demo的顺序，是不会出现问题的 -> Playground.

代码下面的总结部分说的蛮明白的，反复读几遍应该就不会困惑了

[xianfuxing]

断断续续看了好多天，慢慢消化

[small-white0-0]

@Nanbert

费解啊，之前一章说生命周期的标注不会改变引用的真实生命周期，但本章第一个例子，按大佬的解释好像就改变了。。。

我觉得第一个例子的最后一段话说得很合理：“上述代码实际上完全是正确的，但是因为生命周期系统的“粗糙实现”，导致了编译错误，目前来说，遇到这种生命周期系统不够聪明导致的编译错误，我们也没有太好的办法，只能修改代码去满足它的需求，并期待以后它会更聪明。”

我的理解就是变量作用域已经消失了，但是借用检查器认为其生命周期还存在。感觉是理论“生命周期小于等于作用域”，实际是“多数生命周期小于等于作用域”。

loan 实际是一个对于foo的第一次可变借用&mut foo的重借用。所以需要 loan =》 mfoo =》 foo, 这么一个关系，去保证借用的安全性。（这里把mutate_and_share,第一次调用时重借用的 &mut foo 取名为mfoo, 避免歧意。）所以借用检查器就认为 loan存在，即mfoo存在，mfoo导致foo无法再产生其他的借用。但是理论上来说，函数调用中的重借用在离开函数的时候就应该作用域消失了。

但是 loan =》 mfoo =》 foo这种间接的关系有存在意义。如下的代码，如果直接使用 loan =》 foo 的关系，那么在已经可变借用mfoo的情况下就出现了一个不可变借用，这个是不符合借用规则的（但是应该是有使用意义吧？）。所以为了符合借用规则，重借用的关系记录就是loan =》 mfoo =》 foo。

let mut foo = Foo;
let mfoo = &mut foo;
let loan = mfoo.mutate_and_share();
println!("{:?}",loan);

PS： 这里实际是“loan” =》 &mut *mfoo =》mfoo =》 foo 的依赖关系，但是方便阐述，简化了对于可变借用mfoo的重借用描述。
PS： 关于重借用的坑感觉还多。现在官方的手册里面也没有一个章节讲这个几乎无处不在的隐式的重借用机制。

总而言之，当前的借用检查器还不是尽善尽美的。个人理解：要么“生命周期小于等于实际作用域”理解为”多数生命周期小于等于作用域“； 要么就函数调用的重借用机制理解为“重借用的临时变量，可能由于函数的生命周期标注导致作用域延长。“

[busgo]

编译期默认会怎么同一个生命周期的

[sunface]

这章的爬坡陡度太高了，可能是基础知识还是没掌握

后面会对生命周期两个章节进行下大幅优化，目前确实存在一些问题

[0oYGZo0]

当方法的参数为可变引用时需要特别小心，一方面可能不经意传递生命周期参数给返回值，一方面可能不经意跟类型活得一样久，以上两种情况比较容易违反引用规则。也许，可以就方法的参数为可变引用时组织下相关内容。文章内容是相当好。

[MarbleGateKeeper]

最后的这个例子中的错误实在是...太反直觉了。

[guodafeng]

&*self 是为什么， 不能是&self呢

[fadedzipper]

可以把它理解成c++不能有引用的引用，它自动做了*self。但rust可以。
rust里面我想要创建一个对象的新引用，我不是创建一个引用的引用，而是用这个对象再创建一个新引用。

[fadedzipper]

上面那个同学的例子可以是因为强制声明了类型，自动推断类型的时候会显示 &&Point

[aa1ss2]

不强制声明类型也可以执行,主要是因为编译器识别出了类型执行了Deref.
编译器知道强制声明的类型是错误并作出了改正
在调试器下观察就知道
let rr: &Point = &*r;
let rr: &Point = &r;
并不相等
let rr: &Point = &*r;只是相当于复制了一个指向p的指针

[qt911025]

你是说例子1吗？

fn mutate_and_share(&mut self) -> &Self {
    &*self
}

你应该把&mut也看作是类型的一部分，把self当一般参数的格式，就是这样的：

fn mutate_and_share(self: &mut Self) -> &Self {
    &*self
}

self的类型就是自身的一个可变引用，返回值是一个不可变引用，所以要解引用再引用。
（原语法确实有迷惑性，会让人觉得是个析取赋值）

[17998384]

其实就是再借用，但实际地址是一样的，你可以打印出来试试

[kaixinbaba]

看前：我是新手，就是想头铁 0 0
看后：吗的，我在干嘛？

[sunface]

难道不是：什么破书😆

[xusanduo08]

看前：我想挑战下自己
看后：我当个新手吧

[Kangaxx-0]

建议加入Variance相关的知识点，目前的内容貌似没有cover这块难点

[YageGeng]

附议，变性确实需要拿出来讲一讲

[Linuxdazhao]

入门感觉不需要，又会增加此文的复杂度

[giveahug]

&self &Self &*self self 啥区别啊，越看越蒙😒

[Mota-Link]

Self表示实现了该方法的类型，&Self表示该类型的引用；
self表示传入实例方法的参数名，&self是self: &Self的缩写语法糖；
（self单独作参数时，是self: Self的缩写语法糖）
&*self在例子中是对参数self: &mut Self的不可变再借用。

[aa1ss2]

&*self表示再借用,其实底层就是复制了一个指针

[duanyuluo]

可以这么理解：*self是表示self指向的内存块，&(*self)就是对这块内存再取一次地址。
let r = self;
let r = &*self;
结果都是r指向同一块内存，但是有区别的，想一下？：D

[Nakiamii]

在结构体那章说的很清楚了，&self 和 &mut self 是官方给的de- sugar。
&self 等价与 self: &Self
&mut self 等价与 self：&mut Self

[qt911025]

*self是对self（self的类型是&mut Self）解引用的意思，&*self就是&(*self)
解引和创建引用都是对右边的操作，所以像&*&**a这种优先级是&(*(&(*(*a))))
解引用仍是借用，不会获得所有权。
对引用取成员的操作隐式调用了解引，解到没引用。
同时取得的成员也是一个已解引的引用（是否可变取决于正主是否可变）

[ChestnutYueyue]

无语感觉自己在看天书了。。。太玄幻了

[sunface]

抱歉，可能写得不够通俗易懂 🤣

[compdzwio]

已经很通俗易懂了。

[17998384]

已经写的很好了

[SuanCaiYv]

写的很通俗易懂！飞哥🐂🍺

[wuyuz]

大佬，针对例2的情况怎么解决那？
fn get_default<'m, K, V>(map: &'m mut HashMap<K, V>, key: K) -> &'m mut V
where
K: Clone + Eq + Hash,
V: Default,
{
match map.get_mut(&key) {
Some(value) => value,
None => {
map.insert(key.clone(), V::default());
map.get_mut(&key).unwrap()
}
}
}

[kiko-Y]

fn get_default<'m, K, V>(map: &'m mut HashMap<K, V>, key: K) -> &'m mut V
where K: Eq + Hash + Clone, 
      V: Default {
    if let None = map.get_mut(&key) {
        map.insert(key.clone(), V::default());
    };
    map.get_mut(&key).unwrap()
}

这样也能过

[tmtbe]

match map.get_mut(&key) {
            Some(_) => map.get_mut(&key).unwrap(),
            None => {
                map.insert(key.clone(), V::default());
                map.get_mut(&key).unwrap()
            }
        }

这样可以过，主要是不能在Some里拿到value直接返回。
我们把原本的代码改一下，不用match，改成这样，依旧是错误的：

let a = map.get_mut(&key);
        if let Some(value) = a {
            value
        }else{
            map.insert(key.clone(), V::default());
            map.get_mut(&key).unwrap()
        }

但是改造成这样又是对的：

        let a = map.get_mut(&key);
        if let Some(_) = a {
            map.get_mut(&key).unwrap()
        } else {
            map.insert(key.clone(), V::default());
            map.get_mut(&key).unwrap()
        }

我们再换一种写法：

        let a = map.get_mut(&key);
        if a.is_some(){
            a.unwrap()
        }else{
            map.insert(key.clone(), V::default());
            map.get_mut(&key).unwrap()
        }

这种写法依旧报错，改成如下又是可以的：

        let a = map.get_mut(&key);
        if a.is_some() {
            map.get_mut(&key).unwrap()
        } else {
            map.insert(key.clone(), V::default());
            map.get_mut(&key).unwrap()
        }

本质上就是你不能将map.get_mut(&key)赋值给一个生命周期很长的临时变量，虽然a在if的第二个分支没再使用了，但对于编译器来说不会考虑if的分支，而是一直到最后

        let a = map.get_mut(&key);
        if a.is_some() {
            let b=map.get_mut(&key);
            b.unwrap()
        } else {
            map.insert(key.clone(), V::default());
            map.get_mut(&key).unwrap()
        }

上面这种b生命周期很短，所以没有关系，是可以编译通过的

[z-yn]

初学Rust不到一周的菜鸟，可能是我理解不到位。

示例2的错误根源还是因为函数返回的生命周期设计，因为你返回了这个变量，那么按照生命周期语义

 fn get_default<'m, K, V>(map: &'m mut HashMap<K, V>, key: K) -> &'m mut V

返回值的生命周期至少跟map参数的生命周期一样长。 此时如果你将函数内的变量返回。则相当于函数内的变量绑定了返回值，那函数内这个变量无论是声明到哪里。都会认为至少比map参数的生命周期一样长，所以导致了之后的map一直处于借用状态。所以,即使是下面代码也是无法编译通过的。

if true {
        let option = map.get_mut(&key);
        if option.is_some() {
            return option.unwrap();
        }
    }
    map.insert(key.clone(), V::default());
    map.get_mut(&key).unwrap()

[suncunqian]

fn main() {
    use std::collections::HashMap;
    use std::hash::Hash;
    fn get_default<K, V>(map: & mut HashMap<K, V>, key: K) -> & mut V
    where
        K: Clone + Eq + Hash,
        V: Default,
    {
        // match map.get_mut(&key) {
        //     Some(value) => value,
        //     None => {
        //         map.insert(key.clone(), V::default());
        //         map.get_mut(&key).unwrap()
        //     }
        // }
        map.entry(key).or_insert(V::default())
    }
}

[zcjie1]

关于if分支的问题：我认为是CPU在处理分支时，其实是两个分支同时开始执行，再判断条件是否成立，继而选择正确的分支继续执行。
所以，可以把分支（if分支，或match分支）看做是并行处理的代码，就可以理解为什么不能编译了

[Johannnnn506]

关于再借用

fn main() {
    let mut p = Point { x: 0, y: 0 };
    let r = &mut p;

    let rr: &mut Point = &mut *r;
    rr.move_to(2, 3);
    println!("{:?}", rr);

    let rrr: &mut Point = &mut *rr;
    rrr.move_to(3, 4);
    println!("{:?}", rrr);

    println!("{:?}", r);
}

这是可以运行的。

我理解是：
这里就是用了一个安全的方式给变量起别名，因为它们本质上都是对p的可变借用。只是它们的生命周期都必须比被自己起别名的变量短，在它们各自的生命周期里面其实都是同样的一个指针，只是在这一段我们叫它r，另一段我们叫它rr...
当然这样的话，只有最开始的借用的才有真实的借用过程，显然不可以开始不可变借用然后二次借用采用可变借用。而初次借用的是可变的，二次借用无论可变或者是不可变都可以，因为其实是一个东西。

理解的对吗？

[Johannnnn506]

同意。
再考虑了一下感觉这个概念主要只是告诉我们在调用函数传参的时候实际机制是什么，就是在传参的时候发生了一次再借用来确保函数结束不会drop掉原先的引用。这么一想还挺优雅的。
似乎也没有什么别的必须要用到这个概念的地方了？

[Mota-Link]

不只是函数传参噢，所有将可变引用赋值给位置的行为，都可能发生再借用，前提是要先明确变量的类型。例如：

    let x = &mut 0_i32; // Move：因为x的类型未知，需要推导
    let y: &mut i32 = x; // Reborrow：y的类型已知

这个现象是因为再借用需要根据目标类型，判断再借用为& *T还是&mut *T。

[Johannnnn506]

感谢回复！
关了rust-analyzer尝试了几种写法才明白你的意思。Interesting...

[anson0370]

探讨一下这个 thread 。

先上个例子：

#[derive(Debug)]
struct S(i32);

impl S {
    fn add(&mut self, v: i32) {
        self.0 += v;
    }
}

fn main() {
    let mut s = S(1);
    let r = &mut s;
    // let rr = r; // 这样写是不行的，这样就变成了 move 而不是 reborrow
    // let rr = &mut *r; // 这样写就行了
    let rr: &mut S = r;

    println!("{:?}", rr);
    r.add(1);
    println!("{:?}", r);
}

实际上 let rr = r; 这句开了 rust-analyzer 是能看到类型推导出来就是 &mut S ，逻辑上和下面那句 let rr: &mut S = r; 应该没有区别才对。而且 let rr = &mut *r; 也是可以的，这个时候 rr 的类型也是推导出来的。
以下是我的猜测：

• 首先我们已知 let b = a; 是 move ，let b = &a; 是 borrow 。
• 猜测类型推导发生在 move / borrow 的判断之后。
• 对于 let rr = r; 编译器作为 move 处理。
• 对于 let rr = &mut *r; 编译器作为 borrow 处理，因为右边显式出现了引用。
• 对于 let rr:&mut S = r; 编译器作为 borrow 处理，因为左边显式出现了引用。
• 编译器基于 NLL 对于 borrow 进行了优化，即为 reborrow 。而 move 不适用于 NLL ，因此报错。

那么我的问题就变成了：

1. 对引用的 move 有意义吗？如果对引用的 move 其实是无意义的，所有情况都可以适用 reborrow 来处理的话，是否 rust 编译器应该将对引用的绑定动作都当成 borrow 处理？
2. 如果确实需要区分，这在语法上的区别是不是有点太微妙了……

[aa1ss2]

其他不太清楚,毕竟小白一个,有个显而易见的意义就是性能,借用是要进行拷贝的,需要保存的空间和执行指令.而move是在编译器层级了,对性能没有影响.

[zhwei820]

多看几遍

[PigFairySpa]

rustc 1.61.0 第一个例子可以了

[zd08135]

1.62.1，还是不行

[ichsonx]

都说学rust是陡坡，感觉形容悬崖更合适。
另外请教下作者大大：个人目前看来rust的coding难度还是比较高的，开发效率应该不高吧？

[sunface]

开发效率取决于多个方面。单论编码效率肯定是比不上 go、python 的，但是熟练后不算低 ：）

[ichsonx]

开发效率取决于多个方面。单论编码效率肯定是比不上 go、python 的，但是熟练后不算低 ：）

我也是go转过来的，go的编码确实还是挺舒服的，除了很多的if nil之外。
可否请教下，你是因什么原因转向rust呢？

[sunface]

开发效率取决于多个方面。单论编码效率肯定是比不上 go、python 的，但是熟练后不算低 ：）

我也是go转过来的，go的编码确实还是挺舒服的，除了很多的if nil之外。 可否请教下，你是因什么原因转向rust呢？

都在用。。适用场景其实不太冲突

[jyutjyu]

真复杂。好难懂。

[lithbitren]

关于闭包，强行标注生命周期也是可以通过编译的，就是费劲，还是普通函数好。

let closure_slision: &dyn for<'x> Fn(&'x i32) -> &'x i32 = &|x: &i32| -> &i32 { x };

[G00dFuture]

fn main() {

let closure_slision = fun(&1);

let closure_slision2 = fun2(|x: &i32| -> &i32 {x});

println!("{}", closure_slision(&2));
println!("{}", closure_slision2(&1));

}

fn fun<'a>(x: &'a i32) -> impl Fn(&'a i32) -> &'a i32 {
|x| x
}

fn fun2<T, F: Fn(&T) -> &T>(f: F) -> F {
f
}

[tjw123hh]

fn main() {
    let closure: &dyn Fn(&i32) -> &i32 = &|x| { x };
    println!("{}", closure(&114))
}

根据编译器的提示一步步改的，没想到最后过了
直接强行用函数的方法推导出来生命周期了

[tjw123hh]

其实编译器完全可以自己推导出来的
而且闭包的写法完全可以和函数一样（

[cctga]

这个闭包只是把函数写成了闭包的样子，所以确实可以完全处理的和函数一样，但是对于有捕获外部变量的闭包，就不好处理了，因为编译器需要推测返回变量的来源，如果来源于外部就会比较复杂，应该是为了语法的一致性或者还没有搞，所以闭包都没有进行处理

[sohide]

What I need is another C, not another C++language

[ThenMorning]

use std::vec::Vec;
fn read_length(strings: &mut Vec) -> usize {
strings.len()
}
这个代码不涉及再借用吧？

[small-white0-0]

涉及
首先解糖方法点调用。

use std::vec::Vec;
fn read_length<T>(strings: &mut Vec<T>) -> usize {
  Vec::len(strings)
}

然后Vec::len需要的是& Vec，引用类型不匹配，需要转换为不可变引用。

use std::vec::Vec;
fn read_length<T>(strings: &mut Vec<T>) -> usize {
  Vec::len(&*strings)
}

&*是明显的一个重借用的标志。不过，这个重借用机制是为了适应函数调用，才搞出来的机制。否则，引用在函数传惨方面会有巨大阻碍。所以一般只要是引用传参的函数，基本多数时候都会涉及重借用。并且这个重借用是隐式发生的，例如第一个只解糖方法点调用语法的代码是可以跑的。

但是，一般情况，这个东西可以不用管它的。毕竟官方文档中我记得这个机制就没有什么介绍。它只是为了让rust的编译系统必须的规则，但是对于我们写代码的人，不知道也没关系。如果代码生命周期绕的乱七八糟的，个人建议把某些函数返回值改为返回所有权。否则，过于复杂的生命周期，不利于代码可读性，也不利于通过编译。 :(

[ThenMorning]

我去，怀疑人生了，多谢讲解

[serveryang]

rust最大的难点就是生命周期设计了。哎，学习起来好吃力！

[aakejiang]

'a:'b，表示 'a 至少要活得跟 'b 一样久。
——
把OOP那一套带进来了。。。'a 是 'b 的子类，子类应该活的比父类短才对。。所以对于OOP过来的人比较难理解

[MaJinjie]

最后一个例子可以理解为：通过新建一个生命周期，传递给借用对象，缩短再借用的时间。
重要的是将再借用与List<'a>解绑，单独计算。

[YaQia]

不太聪明的生命周期检查的第一个例子很好解决，甚至都不需要移动代码位置。这里很明显是需要使用foo变量的引用传入给share，直接把loan传入就好了。

#[derive(Debug)]
struct Foo;

impl Foo {
    fn mutate_and_share(&mut self) -> &Self {
        &*self
    }
    fn share(&self) {}
}

fn main() {
    let mut foo = Foo;
    let loan = foo.mutate_and_share();
    loan.share();
    println!("{:?}", loan);
}

[ARCJ137442]

【2024-09-21 19:21:53】附上一个实战中碰到、同样诡异的例子：

struct S {
    a: String,
}

impl S {
    fn get_non_empty_a(&self) -> Option<&str> {
        if self.a.is_empty() {
            None
        } else {
            Some(&self.a)
        }
    }

    fn get_a_or_inset_new(&mut self, input_s: &str) -> Option<&str> {
        // ↓这里借用了&self，&mut self生命周期结束
        let may_empty_a = self.get_non_empty_a();
        if let Some(a) = may_empty_a {
            Some(a)
        } else {
            // 但这里又要借用&mut self
            self.a = input_s.to_string(); // ! 报错：cannot assign to `self.a` because it is borrowed
            Some(&self.a)
        }
    }
}

完整编译器报错参考：

error[E0506]: cannot assign to `self.a` because it is borrowed
  --> src\lib.rs:21:13
   |
14 |     fn get_a_or_inset_new(&mut self, input_s: &str) -> Option<&str> {
   |                           - let's call the lifetime of this reference `'1`
15 |         // ↓这里借用了&self，&mut self生命周期结束
16 |         let may_empty_a = self.get_non_empty_a();
   |                           ---- `self.a` is borrowed here
17 |         if let Some(a) = may_empty_a {
18 |             Some(a)
   |             ------- returning this value requires that `*self` is borrowed for `'1`
...
21 |             self.a = input_s.to_string(); // ! 报错：cannot assign to `self.a` because it is borrowed
   |             ^^^^^^ `self.a` is assigned to here but it was already borrowed

[ShyunnY]

针对最后一个例子，给出自己的一些想法:

[ShyunnY]

针对最后一个例子，给出自己的一点想法:

// (8) 一个复杂的例子
    {
        #[allow(dead_code)]
        struct Interface<'b, 'a: 'b> {
            manager: &'b mut Manager<'a>,
        }

        #[allow(dead_code)]
        impl<'b, 'a: 'b> Interface<'b, 'a> {
            pub fn noop(self) {
                println!("interface consumed");
            }
        }

        #[allow(dead_code)]
        struct Manager<'a> {
            text: &'a str,
        }

        #[allow(dead_code)]
        struct List<'a> {
            manager: Manager<'a>,
        }

        #[allow(dead_code)]
        impl<'a> List<'a> {
            // 我们给予了一个额外的生命周期参数 'b
            // 这个'b 给予了 Interface 中的 manager, 'a 给了 Interface 中 manager 的text
            // 所以此时 Interface 对 manager 的可变借用跟list不挂钩了, 之前是挂钩的, 因为用的都是 'a
            pub fn get_interface<'b>(&'b mut self) -> Interface<'b, 'a>
            where
                'a: 'b,
            {
                Interface {
                    manager: &mut self.manager,
                }
            }
        }

        #[allow(dead_code)]
        fn xx() {
            let mut list = List {
                manager: Manager { text: "hello" },
            };

            list.get_interface().noop();

            println!("Interface should be dropped here and the borrow released");

            // 下面的调用可以通过，因为Interface的生命周期不需要跟list一样长
            use_list(&list);
        }

        // 因为 use_list 对 List 进行了不可变借用, 并且使用到其内部的 manager
        // 必须保证 manager 此时是不存在可变借用的
        // 如果按照原来的 'a , 那么此时 Interface 中的 manager 还是持有跟list一样长的可变借用, 这违反了借用法则
        // 所以给予了 'b 之后, Interface 中的 manager 没有持有这么长的可变借用了, 此时可以用
        fn use_list(list: &List) {
            println!("{}", list.manager.text);
        }
    }

[coderxiaopin]

struct ImportantExcerpt<'a> {
part: &'a str,
}

impl<'a: 'b, 'b> ImportantExcerpt<'a> {
// 这里一直不太明白，是不是可以理解为，方法需要返回生命周期较短的标注，因为写死了'b,所以需要标注'a:'b ??
fn announce_and_return_part(&'a self, announcement: &'b str) -> &'b str {
println!("Attention please: {}", announcement);
self.part
}
}

[17998384]

so easy

[BloomingStone]

写的很好，就是个人觉得可能有时候对生命周期进行下命名也是很好的，比如最后一个例子中如果用 'm 'i替换掉'a 'b 个人觉得会好理解很多，也更能体现出：“interface是manager临时暴露的对外接口”这种概念.

稍微魔改了一下最后一个例子

struct Manager<'m> {
    text: &'m str
}

struct Interface<'i, 'm: 'i> {
    manager: &'i mut Manager<'m>
}

impl<'i, 'm> Interface<'i, 'm> {
    pub fn rewrite<'s>(&'i mut self, text: &'s str)
    where 's: 'm
    {
        self.manager.text = text;
    }
}

struct ManagerList<'m> {
    manager_list: Vec<Manager<'m>>
}

impl<'m> ManagerList<'m> {
    // 重点是这里的 self: &'i mut Self 的生命周期要和返回值 Interface 一样。
    // 如果还是 `&'m mut self` 的话仍然不能通过编译。
    //
    // 以及，在当前例子中，下面的`where 'm: 'i`和Interface声明中的`'m: 'i`不
    // 是必须的，因为结构体和其中的元素生命周期可以不一样。只不过删去
    // 后的二者的关系就和我们设想的有所出入了。
    pub fn get_interface<'i>(&'i mut self, index: usize) -> Interface<'i, 'm>
    where 'm: 'i
    {
        if index >= self.manager_list.len() {
            panic!("index out of bounds");
        }
        Interface {
            manager: &mut self.manager_list[index]
        }
    }
}

fn print_list(list: &ManagerList) {
    for i in 0..list.manager_list.len() {
        println!("{}", list.manager_list[i].text)
    }
}

fn main() {
    let mut list = ManagerList {
        manager_list: vec![Manager { text: "hello" }]
    };
    print_list(&list);
    
    list.get_interface(0).rewrite("world");
    println!("Interface should be dropped here and the borrow released");
    
    print_list(&list);
}