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编程之道>>, 张汉东著
• https://github.com/ZhangHanDo...