Rust点滴: 闭包那点事儿

概述

咱们经常须要回调函数的功能, 须要函数并非在建立时执行, 而是以回调的方式, 在须要的时候延迟执行. 而且, 经常须要在函数中获取环境中的一些信息, 又不须要将其做为函数参数传入. 这种应用场景就须要闭包这一工具了.

闭包是持有外部环境变量的函数. 所谓外部环境, 就是指建立闭包时所在的词法做用域.

闭包的语法: |params| {expr}

其中params表示向闭包中传递的参数, 相似于函数参数. 能够显式指定类型, 也可由编译器自动推导.

expr表示闭包中的各类表达式, 其返回值类型做为为闭包的返回值类型.

let a = "hello";
let print = || {println!("{:?}", a);};
print();
复制代码

上面的代码段建立了一个闭包, 打印环境变量a的值, 没有传入参数, 返回值类型为().

分类

使用环境变量的方式

Rust中的闭包, 按照对捕获变量的使用方式, 将闭包分为三个类型: Fn, FnMut, FnOnce. 其中Fn类型的闭包, 在闭包内部以共享借用的方式使用环境变量; FnMut类型的闭包, 在闭包内部以独占借用的方式使用环境变量; 而FnOnce类型的闭包, 在闭包内部以全部者的身份使用环境变量. 因而可知, 根据闭包内使用环境变量的方式, 便可判断建立出来的闭包的类型.

注意, 对于Copy类型的环境变量, 若是以传值的方式使用, 其默认的闭包类型是Fn, 而非FnOnce, 而对非Copy的环境变量, 其闭包类型只能是FnOnce.

闭包中环境变量最终的捕获方式 (即, 是借用, 是复制, 仍是转移全部权), 还与环境变量自己的语义, 以及闭包是否强制获取环境变量的全部权有关.

举例说明:

#![feature(fn_traits)]
fn main() {
    let mut a = 1;
    let mut print = || {
        &a;
    };

    print.call_once(()); // OK
    print.call_mut(()); // OK
    print.call(()); // OK
}
复制代码

#![feature(fn_traits)]
fn main() {
    let mut a = 1;
    let mut print = || {
        &mut a;
    };

    print.call_once(()); // OK
    print.call_mut(()); // OK
    print.call(()); // error, the requirement to implement `Fn` derives from here
}
复制代码

#![feature(fn_traits)]
fn main() {
    let mut a = 1;
    let mut print = || {
        a;
    };

    print.call_once(()); // OK
    print.call_mut(()); // OK
    print.call(()); // OK
}
复制代码

最后这个比较神奇, 印象中觉得Copy和非Copy的环境变量, 而实际上建立的闭包因为环境变量都是Copy的, 默认实现了Fn. 若是是非Copy的环境变量, 则只能实现FnOnce.

#![feature(fn_traits)]
fn main() {
    let mut a = "str".to_string();
    let mut print = || {
        a;
    };

    print.call_once(()); // OK
    print.call_mut(()); // error, the requirement to implement `FnMut` derives from here
    print.call(()); // error, the requirement to implement `Fn` derives from here
}
复制代码

是否强制move

在闭包的管道符前面加上move关键字, 会强制以传值的方式捕获变量. 至因而复制仍是移动, 则与环境变量类型的语义有关. 咱们知道, 一个类型实现Copy, 即为复制语义. 在做为右值使用时会将值按位复制. 而未实现Copy的类型即为移动语义, 做右值使用时会转移全部权.

举个例子:

// 没有强制move, 不强制按值捕获变量
fn main() {
    let mut a = 1;
    let print = || {
        &a;
    };
    let aa = &mut a; // 这里编译报错, mutable borrow occurs here
    print();
}
复制代码

之因此声明可变借用aa编译报错, 是由于建立闭包时, 因为是使用可变借用, 所以默认按可变借用捕获环境变量a. 咱们知道, 可变借用和不可变借用不能同时使用.

// 强制move, 按值捕获变量
fn main() {
    let mut a = 1;
    let print = move || { // 这里添加move, 强制按值捕获变量
        &a;
    };
    let aa = &mut a; // 这里不报错, 由于闭包中复制了a的值
    print();
}
复制代码

环境变量的语义

虽然环境变量的类型的语义不影响捕获方式, 但却会影响建立出来的闭包的性质. 若是全部捕获的环境变量均为Copy, 则闭包为Copy, 不然闭包为非Copy, 须要移动.

举个例子:

// 环境变量是Copy, 则闭包是Copy
fn main() {
    let mut a = 1;
    let print = move || {
        a;
    };
    let print2 = print; // 由于闭包只捕获了a, 而a是i32是Copy的, 因此print是Copy的
    print(); // 这里没有发生全部权转移, 是按位复制, print仍然可用
    print2();
}
复制代码

// 环境变量非Copy, 则闭包非Copy
fn main() {
    let mut a = 1;
    let mut s = "str".to_string();
    let print = move || {
        a;
        s;
    };
    let print2 = print;
    print(); // 这里就要报错了, value used here after move
    print2();
}
复制代码

用法

闭包的用法在<<Rust编程之道>>这本书中有比较详细的说明, 主要有两种用法, 做为函数参数, 做为函数返回值. 其中, 做为函数返回值时, 须要注意FnOnce须要特殊处理, Rust会将其封装成FnBox, 从而解决闭包trait对象在解引用时的拆箱问题.

其余

##闭包的逃逸性 根据一个闭包是否会逃逸到建立该闭包的词法做用域以外, 能够将闭包分为非逃逸闭包和逃逸闭包.

这两者最根本的区别在于, 逃逸闭包必须复制或移动环境变量. 这是很显然的, 若是闭包在词法做用域以外使用, 而其若是以引用的方式获取环境变量, 有可能引发悬垂指针问题.

逃逸闭包的类型声明中, 须要加一个静态生命周期参数'static.

// 非逃逸闭包, 不按值捕获环境变量也能够编译经过
fn main() {
    let a = 1;
    let c: Box<Fn()> = Box::new(|| {
        &a;
    });
}
复制代码

// 显式声明类型为逃逸闭包, 不按值捕获环境变量会编译失败
fn main() {
    let a = 1;
    let c: Box<Fn()+'static> = Box::new(|| { &a; // error, borrowed value does not live long enough }); } 复制代码

// 显式声明类型为逃逸闭包, 按值捕获环境变量, 编译经过
fn main() {
    let a = 1;
    let c: Box<Fn()+'static> = Box::new(move || { &a; }); } 复制代码

高阶生命周期

主要解决闭包参数中含有引用时的生命周期标注的问题. Rust经过高阶trait限定的for<>语法, 解决这一问题.

总结

闭包的几个关键点:

• 闭包如何捕获环境变量: 与环境变量是否Copy, 是否强制move有关.
• 闭包类型: 与环境变量是否Copy, 环境变量在闭包中的使用方式有关.
• 闭包在什么时候使用环境变量: 涉及闭包的逃逸性, 逃逸闭包必须传值.

参考资料

• <<Rust编程之道>>, 张汉东著
• github.com/ZhangHanDon…