Rust学习实践（三） -- Rust特性：生命周期及函数式编程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 此处生命周期标注仅仅说明，这两个参数 x、y 和返回值至少活得和 'a 一样久(因为返回值要么是 x，要么是 y)
// 实际上，这意味着返回值的生命周期与参数生命周期中的较小值一致
// 由于返回值的生命周期也被标记为 'a，因此返回值的生命周期也是 x 和 y 中作用域较小的那个
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

// 编译会出错，因为result的访问超出了string2的作用域（最小的那个生命周期）
fn return_lifetime() {
    let string1 = String::from("long string is long");
    let result;
    {
        let string2 = String::from("xyz");
        // 此处会编译报错（括号外使用了result），
        // 因为 longest 返回的生命周期是 string1和string2中较小的那个生命周期，离开括号后string2的生命周期已经结束
        result = longest(string1.as_str(), string2.as_str());
    }
    // 注释下面这条访问result的语句，则不会报错，只是警告上面的result没使用
    println!("The longest string is {}", result);
}

1
2
3
4
// 先声明生命周期，再使用生命周期标注
struct ImportantExcerpt<'a> {
    part: &'a str,
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// 需要保证结构体中引用字段的生命周期 比 结构体本身的生命周期 **更长**
fn test_success() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'");
    let text = ImportantExcerpt {
        part: first_sentence,
    };
    println!("info: {:?}", text);
}

// 编译失败
fn test_failed() {
    // 结构体定义
    let text;

    {
        let novel = String::from("Call me Ishmael. Some years ago...");
        // next() 返回一个 Option<&'a str>，成功时，返回一个切片引用
        let first_sentence = novel.split('.').next().expect("Could not find a '.'");
        // 引用字段的生命周期 比 结构体本身的生命周期 短，而大括号外又访问了，所以会编译失败（注释外面访问则可正常编译运行）
        text = ImportantExcerpt {
            part: first_sentence,
        };
        // 正常打印
        println!("info1: {:?}", text);
    }
    
    // 大括号外访问，结构体和其中字段引用的生命周期不满足生命周期条件，所以会编译失败
    println!("info2: {:?}", text);
}

1
2
3
4
5
6
7
8
9
10
struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention please: {}", announcement);
        self.part
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 方式1，通过where添加生命周期约束
impl<'a> ImportantExcerpt <'a> {
    fn print_and_return_part2<'b>(&'a self, info: &'b str) -> &'b str 
    where
        'a : 'b,
    {
        println!("info: {}", info);
        self.part
    }
}

// 方式2: 在函数签名中显式地标注生命周期
impl<'a: 'b, 'b> ImportantExcerpt <'a> {
    // 上面声明了'b，这里就不需要再声明了
    fn print_and_return_part3(&'a self, info: &'b str) -> &'b str {
        println!("info: {}", info);
        self.part
    }
}

1
2
3
4
5
6
7
// 参数 x 是一个裸指针，它并没有任何生命周期，
// 然后通过 unsafe 操作后，它被进行了解引用，变成了一个 Rust 的标准引用类型，该类型必须要有生命周期，也就是 'a
fn f<'a, T>(x: *const T) -> &'a T {
    unsafe {
        &*x
    }
}

1
2
3
4
struct DoubleRef<'a, 'b:'a, T> {
    r: &'a T,
    s: &'b T
}

1
2
3
4
5
6
7
8
9
10
// 结构体字段 r 引用了 T，因此 r 的生命周期 'a 必须要比 T 的生命周期更短(被引用者的生命周期必须要比引用长)。
// 泛型T生命周期更长
struct Ref<'a, T: 'a> {
    r: &'a T
}

// 从 1.31 版本开始，编译器可以自动推导 T: 'a 类型的约束，只需写成如下形式即可
struct Ref<'a, T> {
    r: &'a T
}

1
2
3
4
5
6
7
// 对于函数的生命周期而言，它的消除规则之所以能生效是因为它的生命周期完全体现在签名的引用类型上，在函数体中无需任何体现
fn fn_elision(x: &i32) -> &i32 { x }

// 会报错
// 闭包并没有函数那么简单，它的生命周期分散在参数和闭包函数体中(主要是它没有确切的返回值签名)
// Rust 语言开发者目前其实是有意针对函数和闭包实现了两种不同的生命周期消除规则
let closure_slision = |x: &i32| -> &i32 { x };

1
2
3
4
5
6
7
8
9
10
11
12
13
14
fn test_nll() {
   let mut s = String::from("hello");

    let r1 = &s;
    let r2 = &s;
    println!("{} and {}", r1, r2);
    // 新编译器中(1.31开始)，r1,r2作用域在这里结束

    let r3 = &mut s;
    println!("{}", r3);

    // 若此处还访问r1,r2，则可变引用r3存在，r1,r2被借用，无法访问。编译器会报错
    // println!("{}", r2);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
fn test_reborrow() {
    let mut p = Point { x: 0, y: 0 };
    let r = &mut p;
    // 对于再借用而言，rr 再借用时不会破坏借用规则，但是不能在它的生命周期内再使用原来的借用 r
    let rr: &Point = &*r;
    // rr最后一次使用，基于NLL规则，rr作用域在这里结束

    println!("{:?}", rr);
    // 在 rr 的生命周期外，r 依然可以使用
    r.move_to(10, 10);
    println!("{:?}", r);
}

// 上面需要的结构体和方法定义
#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}
impl Point {
    fn move_to(&mut self, x: i32, y: i32) {
        self.x = x;
        self.y = y;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
fn main() {
    let mark_twain: &str = "Samuel Clemens";
    print_author(mark_twain);
    print(mark_twain);
    get_memory_location();
}

// 'static 生命周期
fn print_author(author: &'static str) {
    println!("{}", author);
}

// 特征对象的生命周期也是 'static
// T: 'static
fn print<T: Display + 'static>(message: &T) {
    println!("{}", message);
}

// &'static 生命周期针对的仅仅是引用，而不是持有该引用的变量，对于变量来说，还是要遵循相应的作用域规则
fn get_memory_location() -> (usize, usize) {
    // “Hello World” 是字符串字面量，因此它的生命周期是 `'static`.
    // 但持有它的变量 `string` 的生命周期就不一样了，它完全取决于变量作用域，对于该例子来说，也就是当前的函数范围
    let string = "Hello World!";
    let pointer = string.as_ptr() as usize;
    let length = string.len();
    (pointer, length)
    // `string` 在这里被 drop 释放
    // 虽然变量被释放，无法再被访问，但是"Hello World!"数据依然还会继续存活
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* ================== 基本工作：要求写指定时长的代码 =================== */
fn program(duration: u32) {
    println!("program duration:{}", duration);
}

fn work(time_base: u32, company_type: &str) {
    if company_type == "955" {
        program(time_base * 1);
    } else if company_type == "996" {
        program(time_base * 2);
    } else {
        println!("other company");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/* ================== 新需求1：工作内容修改为写ppt =================== */
// 通过函数变量来修改工作内容
fn write_ppt(duration: u32) {
    println!("write_ppt duration:{}", duration);
}
fn work2(time_base: u32, company_type: &str) {
    // 函数作为参数传递，可以动态修改工作内容
    // let action = program;
    let action = write_ppt;
    if company_type == "955" {
        action(time_base * 1);
    } else if company_type == "996" {
        action(time_base * 2);
    } else {
        println!("other company");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/* ================== 新需求2：工作内容修改为销售，由时长调整为质量等级 =================== */
// 使用闭包，并捕获外部变量
fn work3(level: &str, company_type: &str) {
    let action = || {
        println!("company_type:{}, sell product, achieve level:{}", company_type, level);
    };

    if company_type == "955" {
        action();
    } else if company_type == "996" {
        action();
    } else {
        println!("other company");
    }
}

1
2
3
4
5
fn main() {
    work(8, "955");
    work2(8, "996");
    work3("good", "955");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
fn fn_once<F>(func: F)
where
    F: FnOnce(usize) -> bool,
{
    println!("{}", func(3));
    
    // 下面会报错，因为 FnOnce 只能调用一次，上面调用后 func 的所有权已经转移
    println!("{}", func(4));
    // 上面where子句中，也在约束里添加Copy特征，即：`F: FnOnce(usize) -> bool + Copy,`，
    // 则调用时使用的将是它的拷贝，所以并没有发生所有权的转移。那么第二次调用 func(4) 就不会报错了
}

// 使用方式
fn test_fn_once() {
    println!("=========== test_fn_once ===========");
    let x = vec![1, 2, 3];

    fn_once(|z|{z == x.len()});

    // 如果要强制闭包转移所有权，可以使用在参数列表前加上 `move` 关键字
    // fn_once(move |z|{z == x.len()});
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
fn test_fn_mut() {
    println!("=========== test_fn_mut ===========");
    let mut s = String::new();

    // 若按此处定义，则update_string调用时编译器会报错，内部不支持变量的可变借用。需要将update_string定义为可变闭包
    // 添加mut关键字，可看到rust-analyzer推断其类型为 `impl FnMut(&str)`
    // let update_string = |str| s.push_str(str);

    let mut update_string = |str| s.push_str(str);

    update_string("hello");
    update_string(", world");

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
fn test_fn_mut_param() {
    println!("=========== test_fn_mut_param ===========");
    let mut s = String::new();
    let update_string =  |str| s.push_str(str);
    // 闭包作为参数传递给函数，此处会转移所有权
    exec_fn_mut(update_string);
    println!("{:?}", s);
}

// 泛型参数标注闭包为 FnMut 特征，并传递可变借用
fn exec_fn_mut<'a, F: FnMut(&'a str)>(mut f: F) {
    f("hello2");
    f(", world2");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
fn test_fn_trait() {
    println!("=========== test_fn_trait ===========");
    let mut s = "hello".to_string();

    // 传给 exec_fn 会报错，该闭包中要修改变量，而 Fn 特征要求闭包为不可变借用
    // let update_string =  |str| s.push_str(str);

    let update_string = |str| println!("{}, {}", s, str);
    exec_fn(update_string);

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

// 泛型参数标注闭包为 Fn 特征，并传递不可变借用的闭包
fn exec_fn<'a, F: Fn(&'a str)>(f: F) {
    f("world")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
fn main() {
    let f = factory(2);
    println!("f(3) = {}", f(3));
}

fn factory(x:i32) -> impl Fn(i32) -> i32 {

    let num = 5;
    move |x| x + num

    // 注意：impl Trait 的返回方式有一个非常大的局限，就是只能返回同样的类型
    // 就算签名一样的闭包，类型也是不同的，因此在这种情况下，就无法再使用 impl Trait 的方式去返回闭包
    // if x > 1{
    //     move |x| x + num
    // } else {
    //     move |x| x - num
    // }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
fn test_iter() {
    let arr = [1, 2, 3];
    // 严格来说，Rust中的for循环是编译器提供的语法糖，最终还是对迭代器中的元素进行遍历。
    // 数组实现了 IntoIterator 特征，编译器通过for语法糖，自动把实现了该特征的数组类型转换为迭代器
    for v in arr {
        println!("{}",v);
    }
    // 对数值序列进行迭代
    for i in 1..10 {
        println!("{}", i);
    }
    // 通过IntoIterator特征的 into_iter 方法，显式转换为迭代器
    for v in arr.into_iter() {
        println!("{}", v);
    }
    // 显式定义迭代器，并进行迭代
    let it = arr.iter();
    for v in it {
        println!("{}", v);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
fn test_next() {
    let arr = [1, 2, 3];
    // next 会改变迭代器其中的状态数据，所以迭代器定义时需要使用 mut 关键字
    let mut arr_iter = arr.into_iter();
    // 若通过iter_mut定义迭代器，则迭代器中的数据会自动变为可变数据，下面断言比较需调整为 assert_eq!(arr_iter.next(), Some(&mut 1)); 形式
    // let mut arr_iter = arr.iter_mut();
    // 通过next方法，显式迭代
    assert_eq!(arr_iter.next(), Some(1));
    assert_eq!(arr_iter.next(), Some(2));
    assert_eq!(arr_iter.next(), Some(3));
    assert_eq!(arr_iter.next(), None);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// 定义一个特征
pub trait Summary {
    // 签名，不包含具体实现
    fn summarize_author(&self) -> String;

    // 也可以定义默认实现，为类型impl实现时可进行重载
    fn summarize(&self) -> String {
        format!("(Read more from {}...)", self.summarize_author())
    }
}

// 定义一个类型，并为其实现特征
pub struct Weibo {
    pub username: String,
    pub content: String
}
// 实现特征
impl Summary for Weibo {
    fn summarize_author(&self) -> String {
        format!("@{}", self.username)
    }
}

// 使用方式
fn main() {
    let weibo = Weibo{username: "sunface".to_string(),content: "好像微博没Tweet好用".to_string()};
    println!("{}",weibo.summarize());
}

1
2
3
pub fn notify(item: &impl Summary) {
    println!("Breaking news! {}", item.summarize());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 函数接受一个实现了 Summary特征 的 iterm
pub fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}

// 两个参数是同一类型，且该类型实现了 Summary特征
pub fn notify<T: Summary>(item1: &T, item2: &T) {}

// 多重特征约束，实现了 Summary特征 和 Display特征
pub fn notify<T: Summary + Display>(item: &T) {}
// 不用特征约束的话，可以这么写
pub fn notify(item: &(impl Summary + Display)) {}

// 特征约束很复杂的时候，可以使用 where 简化
fn some_function<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {}
// 用 where约束 简化如下：
fn some_function<T, U>(t: &T, u: &U) -> i32
    where T: Display + Clone,
          U: Clone + Debug
{}

1
2
3
4
5
6
7
8
9
// 对于 returns_summarizable 的调用者而言，只知道返回了一个实现了 Summary 特征的对象，但是并不知道返回了一个 Weibo 类型
fn returns_summarizable() -> impl Summary {
    Weibo {
        username: String::from("sunface"),
        content: String::from(
            "m1 max太厉害了，电脑再也不会卡",
        )
    }
}

1
2
use std::prelude;
// xxx