1
trait Trait {}
2

3
impl<T> Trait for T {}
4

5
impl<T> Trait for &T {} // ❌
6

7
impl<T> Trait for &mut T {} // ❌

1
error[E0119]: conflicting implementations of trait `Trait` for type `&_`:
2
 --> src/lib.rs:5:1
3
  |
4
3 | impl<T> Trait for T {}
5
  | ------------------- first implementation here
6
4 |
7
5 | impl<T> Trait for &T {}
8
  | ^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `&_`
9

10
error[E0119]: conflicting implementations of trait `Trait` for type `&mut _`:
11
 --> src/lib.rs:7:1
12
  |
13
3 | impl<T> Trait for T {}
14
  | ------------------- first implementation here
15
...
16
7 | impl<T> Trait for &mut T {}
17
  | ^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `&mut _`

1
trait Trait {}
2

3
impl<T> Trait for &T {}  // ✅
4

5
impl<T> Trait for &mut T {}  // ✅

1
fn main() {
2
    let str_literal: &'static str = "str literal";
3
}

1
// 注意：这个理智纯粹是为了说明问题。
2
// 永远不要使用`static mut`这种别扭的变量。
3
// 在Rust中，有一些安全的全局可变单例模式，
4
// 但这些不在本文的讨论范围之内。
5

6
static BYTES: [u8; 3] = [1, 2, 3];
7
static mut MUT_BYTES: [u8; 3] = [1, 2, 3];
8

9
fn main() {
10
    MUT_BYTES[0] = 99; // ❌ - 修改静态变量是非安全的
11

12
    unsafe {
13
        MUT_BYTES[0] = 99;
14
        assert_eq!(99, MUT_BYTES[0]);
15
    }
16
}

1
use rand;
2

3
// 在运行时生成随机的'static str引用
4
fn rand_str_generator() -> &'static str {
5
    let rand_string = rand::random::<u64>().to_string();
6
    box::leak(rand_string.into_boxed_str())
7
}

1
use rand;
2

3
fn drop_static<T: 'static>(t: T) {
4
    std::mem::drop(t);
5
}
6

7
fn main() {
8
    let mut strings: Vec<String> = Vec::new();
9
    for _ in 0..10 {
10
        if rand::random() {
11
            // 所以字符串都是随机生成且在运行时动态分配的
12
            let string = rand::random::<u64>().to_string();
13
            strings.push(string);
14
        }
15
    }
16

17
    // 字符串为自有类型，因此受到'static约束
18
    for mut string in strings {
19
        // 所有字符串均可变
20
        string.push_str("a mutation");
21
        // 所有字符串均可析构
22
        drop_static(string);
23
    }
24

25
    // 所有字符串在程序结束前均已失效
26
    println!("I am the end of program");
27
}

1
// 只接受受到'a约束的类型的引用
2
fn t_ref<'a, T: 'a>(t: &'a T) {}
3

4
// 接受任意受到'a约束的类型
5
fn t_bound<'a, T: 'a>(t: T) {}
6

7
// 包含一个引用的自有类型
8
struct Ref<'a, T: 'a>(&'a T);
9

10
fn main() {
11
    let string = String::from("string");
12

13
    t_bound(&string); // ✅
14
    t_bound(Ref(&string)); // ✅
15
    t_bound(&Ref(&string)); // ✅
16

17
    t_ref(&string); // ✅
18
    t_ref(Ref(&string)); // ❌ - 期待收到一个引用，但实际收到一个结构体
19
    t_ref(&Ref(&string)); // ✅
20

21
    // string var is bounded by 'static which is bounded by 'a
22
    // 字符串变量受到'static约束，即受到'a约束
23
    t_bound(string); // ✅
24
}

1
// 省略
2
fn print(s: &str);
3

4
// 展开为
5
fn print<'a>(s: &'a str);
6

7
// 省略
8
fn trim(s: &str) -> &str;
9

10
// 展开为
11
fn trim<'a>(s: &'a str) -> &'a str;
12

13
// 错误，因为没有输入，无法确定输出的生命周期
14
fn get_str() -> &str;
15

16
// 展开的选项包括
17
fn get_str<'a>() -> &'a str; // 泛型版本
18
fn get_str() -> &'static str; // 'static版本
19

20
// 错误，因为有多个输入，无法确定输出的生命周期
21
fn overlap(s: &str, t: &str) -> &str;
22

23
// 展开（依然有部分省略）的选项包括
24
fn overlap<'a>(s: &'a str, t: &str) -> &'a str; // 输出的有效期不能超过s
25
fn overlap<'a>(s: &str, t: &'a str) -> &'a str; // 输出的有效期不能超过t
26
fn overlap<'a>(s: &'a str, t: &'a str) -> &'a str; // 输出的有效期不能超过s和t
27
fn overlap(s: &str, t: &str) -> &'static str; // 输出的有效期可以超过s和t
28
fn overlap<'a>(s: &str, t: &str) -> &'a str; // 输出的生命周期与输入无关
29

30
// 展开为
31
fn overlap<'a, 'b>(s: &'a str, t: &'b str) -> &'a str;
32
fn overlap<'a, 'b>(s: &'a str, t: &'b str) -> &'b str;
33
fn overlap<'a>(s: &'a str, t: &'a str) -> &'a str;
34
fn overlap<'a, 'b>(s: &'a str, t: &'b str) -> &'static str;
35
fn overlap<'a, 'b, 'c>(s: &'a str, t: &'b str) -> &'c str;
36

37
// 省略
38
fn compare(&self, s: &str) -> &str;
39

40
// 展开为
41
fn compare<'a, 'b>(&'a self, &'b str) -> &'a str;

1
struct ByteIter<'a> {
2
    remainder: &'a [u8]
3
}
4

5
impl<'a> ByteIter<'a> {
6
    fn next(&mut self) -> Option<&u8> {
7
        if self.remainder.is_empty() {
8
            None
9
        } else {
10
            let byte = &self.remainder[0];
11
            self.remainder = &self.remainder[1..];
12
            Some(byte)
13
        }
14
    }
15
}
16

17
fn main() {
18
    let mut bytes = ByteIter { remainder: b"1" };
19
    assert_eq!(Some(&b'1'), bytes.next());
20
    assert_eq!(None, bytes.next());
21
}

1
fn main() {
2
    let mut bytes = ByteIter { remainder: b"1123" };
3
    let byte_1 = bytes.next();
4
    let byte_2 = bytes.next();
5
    if byte_1 == byte_2 { // ❌
6
        // do something
7
    }
8
}

1
error[E0499]: cannot borrow `bytes` as mutable more than once at a time
2
  --> src/main.rs:20:18
3
   |
4
19 |     let byte_1 = bytes.next();
5
   |                  ----- first mutable borrow occurs here
6
20 |     let byte_2 = bytes.next();
7
   |                  ^^^^^ second mutable borrow occurs here
8
21 |     if byte_1 == byte_2 {
9
   |        ------ first borrow later used here

1
struct ByteIter<'a> {
2
    remainder: &'a [u8]
3
}
4

5
impl<'a> ByteIter<'a> {
6
    fn next<'b>(&'b mut self) -> Option<&'b u8> {
7
        if self.remainder.is_empty() {
8
            None
9
        } else {
10
            let byte = &self.remainder[0];
11
            self.remainder = &self.remainder[1..];
12
            Some(byte)
13
        }
14
    }
15
}

1
struct ByteIter<'remainder> {
2
    remainder: &'remainder [u8]
3
}
4

5
impl<'remainder> ByteIter<'remainder> {
6
    fn next<'mut_self>(&'mut_self mut self) -> Option<&'mut_self u8> {
7
        if self.remainder.is_empty() {
8
            None
9
        } else {
10
            let byte = &self.remainder[0];
11
            self.remainder = &self.remainder[1..];
12
            Some(byte)
13
        }
14
    }
15
}

1
struct ByteIter<'remainder> {
2
    remainder: &'remainder [u8]
3
}
4

5
impl<'remainder> ByteIter<'remainder> {
6
    fn next(&mut self) -> Option<&'remainder u8> {
7
        if self.remainder.is_empty() {
8
            None
9
        } else {
10
            let byte = &self.remainder[0];
11
            self.remainder = &self.remainder[1..];
12
            Some(byte)
13
        }
14
    }
15
}
16

17
fn main() {
18
    let mut bytes = ByteIter { remainder: b"1123" };
19
    let byte_1 = bytes.next();
20
    let byte_2 = bytes.next();
21
    std::mem::drop(bytes); // 我们甚至可以在此处析构迭代器！
22
    if byte_1 == byte_2 { // ✅
23
        // do something
24
    }
25
}

1
#[derive(Debug)]
2
struct NumRef<'a>(&'a i32);
3

4
impl<'a> NumRef<'a> {
5
    // 我们的结构体以为'a泛型，这是否意味着我需要将self参数也注释为'a？
6
    // （答案：并不是）
7
    fn some_method(&'a mut self) {}
8
}
9

10
fn main() {
11
    let mut num_ref = NumRef(&5);
12
    num_ref.some_method(); // 可变借用num_ref直到其生命周期结束
13
    num_ref.some_method(); // ❌
14
    println!("{:?}", num_ref); // ❌
15
}

1
#[derive(Debug)]
2
struct NumRef<'a>(&'a i32);
3

4
impl<'a> NumRef<'a> {
5
    // 不再给mut self添加'a注释
6
    fn some_method(&mut self) {}
7

8
    // 上面的方法实际上是：
9
    fn some_method_desugared<'b>(&'b mut self){}
10
}
11

12
fn main() {
13
    let mut num_ref = NumRef(&5);
14
    num_ref.some_method();
15
    num_ref.some_method(); // ✅
16
    println!("{:?}", num_ref); // ✅
17
}

1
use std::cell::Ref;
2

3
trait Trait {}
4

5
// 省略
6
type T1 = Box<dyn Trait>;
7
//展开，Box<T>对T没有生命周期约束，因此推断为'static
8
type T2 = Box<dyn Trait + 'static>;
9

10
// 省略
11
impl dyn Trait {}
12
// 展开为
13
impl dyn Trait + 'static {}
14

15
// 省略
16
type T3<'a> = &'a dyn Trait;
17
// 展开，&'a T 要求 T: 'a，因此推断为'a
18
type T4<'a> = &'a (dyn Trait + 'a);
19

20
// 省略
21
type T5<'a> = Ref<'a, dyn Trait>;
22
// 展开，Ref<'a, T> 要求 T: 'a，因此推断为'a
23
type T6<'a> = Ref<'a, dyn Trait + 'a>;
24

25
trait GenericTrait<'a>: 'a {}
26

27
// 省略
28
type T7<'a> = Box<dyn GenericTrait<'a>>;
29
// 展开为
30
type T8<'a> = Box<dyn GenericTrait<'a> + 'a>;
31

32
// 省略
33
impl<'a> dyn GenericTrait<'a> {}
34
// 展开为
35
impl<'a> dyn GenericTrait<'a> + 'a {}

1
trait Trait {}
2

3
struct Struct {}
4
struct Ref<'a, T>(&'a T);
5

6
impl Trait for Struct {}
7
impl Trait for &Struct {} // 直接为引用类型实现Trait
8
impl<'a, T> Trait for Ref<'a, T> {} // 为包含引用的类型实现

1
use std::fmt::Display;
2

3
fn dynamic_thread_print(t: Box<dyn Display + Send>) {
4
    std::thread::spawn(move || {
5
        println!("{}", t);
6
    }).join();
7
}
8

9
fn static_thread_print<T: Display + Send>(t: T) { // ❌
10
    std::thread::spawn(move || {
11
        println!("{}", t);
12
    }).join();
13
}

1
error[E0310]: the parameter type `T` may not live long enough
2
  --> src/lib.rs:10:5
3
   |
4
9  | fn static_thread_print<T: Display + Send>(t: T) {
5
   |                        -- help: consider adding an explicit lifetime bound...: `T: 'static +`
6
10 |     std::thread::spawn(move || {
7
   |     ^^^^^^^^^^^^^^^^^^
8
   |
9
note: ...so that the type `[closure@src/lib.rs:10:24: 12:6 t:T]` will meet its required lifetime bounds
10
  --> src/lib.rs:10:5
11
   |
12
10 |     std::thread::spawn(move || {
13
   |     ^^^^^^^^^^^^^^^^^^

1
use std::fmt::Display;
2

3
fn dynamic_thread_print(t: Box<dyn Display + Send>) {
4
    std::thread::spawn(move || {
5
        println!("{}", t);
6
    }).join();
7
}
8

9
fn static_thread_print<T: Display + Send + 'static>(t: T) { // ✅
10
    std::thread::spawn(move || {
11
        println!("{}", t);
12
    }).join();
13
}

1
use std::fmt::Display;
2

3
fn dynamic_thread_print(t: Box<dyn Display + Send + 'static>) {
4
    std::thread::spawn(move || {
5
        println!("{}", t);
6
    }).join();
7
}
8

9
fn static_thread_print<T: Display + Send + 'static>(t: T) {
10
    std::thread::spawn(move || {
11
        println!("{}", t);
12
    }).join();
13
}

1
use std::fmt::Display;
2

3
fn box_displayable<T: Display>(t: T) -> Box<dyn Display> { // ❌
4
    Box::new(t)
5
}

1
error[E0310]: the parameter type `T` may not live long enough
2
 --> src/lib.rs:4:5
3
  |
4
3 | fn box_displayable<T: Display>(t: T) -> Box<dyn Display> {
5
  |                    -- help: consider adding an explicit lifetime bound...: `T: 'static +`
6
4 |     Box::new(t)
7
  |     ^^^^^^^^^^^
8
  |
9
note: ...so that the type `T` will meet its required lifetime bounds
10
 --> src/lib.rs:4:5
11
  |
12
4 |     Box::new(t)
13
  |     ^^^^^^^^^^^

1
use std::fmt::Display;
2

3
fn box_displayable<T: Display + 'static>(t: T) -> Box<dyn Display> { // ✅
4
    Box::new(t)
5
}

1
use std::fmt::Display;
2

3
fn box_displayable<'a, T: Display + 'a>(t: T) -> Box<dyn Display + 'a> { // ✅
4
    Box::new(t)
5
}

1
fn return_first(a: &str, b: &str) -> &str { // ❌
2
    a
3
}

1
error[E0106]: missing lifetime specifier
2
 --> src/lib.rs:1:38
3
  |
4
1 | fn return_first(a: &str, b: &str) -> &str {
5
  |                    ----     ----     ^ expected named lifetime parameter
6
  |
7
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `a` or `b`
8
help: consider introducing a named lifetime parameter
9
  |
10
1 | fn return_first<'a>(a: &'a str, b: &'a str) -> &'a str {
11
  |                ^^^^    ^^^^^^^     ^^^^^^^     ^^^

1
fn return_first<'a>(a: &'a str, b: &str) -> &'a str { // ✅
2
    a
3
}

1
struct Has<'lifetime> {
2
    lifetime: &'lifetime str,
3
}
4

5
fn main() {
6
    let long = String::from("long");
7
    let mut has = Has { lifetime: &long };
8
    assert_eq!(has.lifetime, "long");
9

10
    {
11
        let short = String::from("short");
12
        // “切换”到short生命周期
13
        has.lifetime = &short;
14
        assert_eq!(has.lifetime, "short");
15

16
        // “切换回”long生命周期（但实际上并没有）
17
        has.lifetime = &long;
18
        assert_eq!(has.lifetime, "long");
19
        // `short`在此处析构
20
    }
21

22
    assert_eq!(has.lifetime, "long"); // ❌ - `short`在析构之后仍“被借用”
23
}

1
error[E0597]: `short` does not live long enough
2
  --> src/main.rs:11:24
3
   |
4
11 |         has.lifetime = &short;
5
   |                        ^^^^^^ borrowed value does not live long enough
6
...
7
15 |     }
8
   |     - `short` dropped here while still borrowed
9
16 |     assert_eq!(has.lifetime, "long");
10
   |     --------------------------------- borrow later used here

1
struct Has<'lifetime> {
2
    lifetime: &'lifetime str,
3
}
4

5
fn main() {
6
    let long = String::from("long");
7
    let mut has = Has { lifetime: &long };
8
    assert_eq!(has.lifetime, "long");
9

10
    // 虽然这个代码块从不执行
11
    if false {
12
        let short = String::from("short");
13
        // “切换”到short生命周期
14
        has.lifetime = &short;
15
        assert_eq!(has.lifetime, "short");
16

17
        // “切换回”long生命周期（但实际上并没有）
18
        has.lifetime = &long;
19
        assert_eq!(has.lifetime, "long");
20
        // `short`在此处析构
21
    }
22

23
    assert_eq!(has.lifetime, "long"); // ❌ - `short`在析构之后仍“被借用”
24
}

1
fn takes_shared_ref(n: &i32) {}
2

3
fn main() {
4
    let mut a = 10;
5
    takes_shared_ref(&mut a); // ✅
6
    takes_shared_ref(&*(&mut a)); // 上一行实际上执行的代码
7
}

1
fn main() {
2
    let mut a = 10;
3
    let b: &i32 = &*(&mut a); // re-borrowed as immutable
4
    let c: &i32 = &a;
5
    dbg!(b, c); // ❌
6
}

1
error[E0502]: cannot borrow `a` as immutable because it is also borrowed as mutable
2
 --> src/main.rs:4:19
3
  |
4
3 |     let b: &i32 = &*(&mut a);
5
  |                     -------- mutable borrow occurs here
6
4 |     let c: &i32 = &a;
7
  |                   ^^ immutable borrow occurs here
8
5 |     dbg!(b, c);
9
  |          - mutable borrow later used here

1
use std::sync::Mutex;
2

3
struct Struct {
4
    mutex: Mutex<String>
5
}
6

7
impl Struct {
8
    // 将可变self降级为共享str
9
    fn get_string(&mut self) -> &str {
10
        self.mutex.get_mut().unwrap()
11
    }
12
    fn mutate_string(&self) {
13
        // 如果Rust允许将可变引用降级为共享引用
14
        // 则下面这行代码将使从get_string方法返回的任何共享引用无效
15
        *self.mutex.lock().unwrap() = "surprise!".to_owned();
16
    }
17
}
18

19
fn main() {
20
    let mut s = Struct {
21
        mutex: Mutex::new("string".to_owned())
22
    };
23
    let str_ref = s.get_string(); // 可变引用降级为共享引用
24
    s.mutate_string(); // str_ref将变得无效，产生悬空指针
25
    dbg!(str_ref); // ❌ - 如我们所料
26
}

1
// 将可变T降级为共享T
2
fn some_function<T>(some_arg: &mut T) -> &T;
3

4
struct Struct;
5

6
impl Struct {
7
    // 将可变self降级为共享self
8
    fn some_method(&mut self) -> &Self;
9

10
    // 将可变self降级为共享T
11
    fn other_method(&mut self) -> &T;
12
}

1
use std::collections::HashMap;
2

3
type PlayerID = i32;
4

5
#[derive(Debug, Default)]
6
struct Player {
7
    score: i32,
8
}
9

10
fn start_game(player_a: PlayerID, player_b: PlayerID, server: &mut HashMap<PlayerID, Player>) {
11
    // 从服务器获取玩家，如果玩家不存在则创建或插入新玩家
12
    let player_a: &Player = server.entry(player_a).or_default();
13
    let player_b: &Player = server.entry(player_b).or_default();
14

15
    // do something with players
16
    dbg!(player_a, player_b); // ❌
17
}

1
use std::collections::HashMap;
2

3
type PlayerID = i32;
4

5
#[derive(Debug, Default)]
6
struct Player {
7
    score: i32,
8
}
9

10
fn start_game(player_a: PlayerID, player_b: PlayerID, server: &mut HashMap<PlayerID, Player>) {
11
    // 丢弃返回的可变Player引用，反正我们也不能同时使用它们
12
    server.entry(player_a).or_default();
13
    server.entry(player_b).or_default();
14

15
    // 重新获取players，这次直接获取其不可变引用，且不带有啊任何隐式重新借用
16
    let player_a = server.get(&player_a);
17
    let player_b = server.get(&player_b);
18

19
    // do something with players
20
    dbg!(player_a, player_b); // ✅
21
}

1
fn function(x: &i32) -> &i32 {
2
    x
3
}
4

5
fn main() {
6
    let closure = |x: &i32| x; // ❌
7
}

1
error: lifetime may not live long enough
2
 --> src/main.rs:6:29
3
  |
4
6 |     let closure = |x: &i32| x;
5
  |                       -   - ^ returning this value requires that `'1` must outlive `'2`
6
  |                       |   |
7
  |                       |   return type of closure is &'2 i32
8
  |                       let's call the lifetime of this reference `'1`

1
// 输入的生命周期应用于输出的生命周期
2
fn function<'a>(x: &'a i32) -> &'a i32 {
3
    x
4
}
5

6
fn main() {
7
    // 输入和输出分别得到了各自不同的生命周期
8
    let closure = for<'a, 'b> |x: &'a i32| -> &'b i32 { x };
9
    // 注意：上面一行代码的语法并不合法，我们只是使用它说明情况
10
}

1
fn main() {
2
    // 若转换为trait对象，占用空间会变得固定，于是产生编译错误
3
    let identity: dyn Fn(&i32) -> &i32 = |x: &i32| x;
4

5
    // 可以分配在堆上，但感觉很笨重
6
    let identity: Box<dyn Fn(&i32) -> &i32> = Box::new(|x: &i32| x);
7

8
    // 可以跳过分配，只创建一个静态引用
9
    let identity: &dyn Fn(&i32) -> &i32 = &|x: &i32| x;
10

11
    // 上面这一行实际上是：
12
    let identity: &'static (dyn for<'a> Fn(&'a i32) -> &'a i32 + 'static) = &|x: &i32| -> &i32 { x };
13

14
    // 这么写是最理想的，但这样的语法是无效的
15
    let identity: impl Fn(&i32) -> &i32 = |x: &i32| x;
16

17
    // 这样写也很理想，但依然是无效语法
18
    let identity = for<'a> |x: &'a i32| -> &'a i32 { x };
19

20
    // `impl trait`只能用在在函数签名的返回值部分
21
    fn return_identity() -> impl Fn(&i32) -> &i32 {
22
        |x| x
23
    }
24
    let identity = return_identity();
25

26
    // 上面版本的泛型化写法
27
    fn annotate<T, F>(f: F) -> F where F: Fn(&T) -> &T {
28
        f
29
    }
30
    let identity = annotate(|x: &i32| x);
31
}