人工智能 谈一谈Fn, FnMut, FnOnce的区别

fzuleishao · December 09, 2019 · 15 hits

在 Rust 里,闭包被分为了三种类型,列举如下

三种闭包的定义

在标准库里是怎么定义的。

  • FnOnce
#[lang = "fn_once"]
pub trait FnOnce<Args> {
    type Output;
    extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
}

参数类型是 self,所以,这种类型的闭包会获取变量的所有权,生命周期只能是当前作用域,之后就会被释放了。

例子:

#[derive(Debug)]
struct E {
    a: String,
}

impl Drop for E {
    fn drop(&mut self) {
        println!("destroyed struct E");
    }
}

fn fn_once<F>(func: F) where F: FnOnce() {
    println!("fn_once begins");
    func();
    println!("fn_once ended");
}

fn main() {
    let e = E { a: "fn_once".to_string() };
    // 这样加个move,看看程序执行输出顺序有什么不同
    // let f = move || println!("fn once calls: {:?}", e);
    let f = || println!("fn once closure calls: {:?}", e);
    fn_once(f);
    println!("main ended");
}

打印的内容差不多是这样的:

fn_once begins
fn once calls: E { a: "fn_once" }
fn_once ended
main ended E { a: "fn_once" }
destroyed struct E

但是如果闭包运行两次,比如:

fn fn_once<F>(func: F) where F: FnOnce() {
    println!("fn_once begins");
    func();
    func();
    println!("fn_once ended");
}

则编译器就报错了,类似这样:

   |
14 |     func();
   |     ---- value moved here
15 |     func();
   |     ^^^^ value used here after move
   |
   = note: move occurs because `func` has type `F`, which does not implement the `Copy` trait

这是为什么呢?

还是回到 FnOnce 的定义,参数类型是 self,所以在 func 第一次执行完之后,之前捕获的变量已经被释放了,所以已经无法在执行第二次了。如果想要运行多次,可以使用 FnMut/FnOnce

  • FnMut
#[lang = "fn_mut"]
pub trait FnMut<Args>: FnOnce<Args> {
    extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
}

参数类型是 &mut self,所以,这种类型的闭包是可变借用,会改变变量,但不会释放该变量。所以可以运行多次。

和上面的例子差不多,有两个地方要改下:

fn fn_mut<F>(mut func: F) where F: FnMut() {
    func();
    func();
}

// ...
let mut e = E { a: "fn_once".to_string() };
let f = || { println!("FnMut closure calls: {:?}", e); e.a = "fn_mut".to_string(); };
// ...

可以看出 FnMut 类型的闭包是可以运行多次的,且可以修改捕获变量的值。

  • Fn
#[lang = "fn"]
pub trait Fn<Args>: FnMut<Args> {
    extern "rust-call" fn call(&self, args: Args) -> Self::Output;
}

参数类型是 &self,所以,这种类型的闭包是不可变借用,不会改变变量,也不会释放该变量。所以可以运行多次。

例子:

fn fn_immut<F>(mut func: F) where F: Fn() {
    func();
    func();
}

// ...
let e = E { a: "fn_once".to_string() };
let f = || { println!("Fn closure calls: {:?}", e); };
fn_immut(f);
// ...

可以看出 Fn 类型的闭包是可以运行多次的,但不可以修改捕获变量的值。

常见的错误

有时候在使用 Fn/FnMut 这里类型的闭包,编译器经常会给出这样的错误:

# ...
cannot move out of captured variable in an Fn(FnMut) closure
# ...

看下如何复现这种情形:

fn main() {
    fn fn_immut<F>(f: F) where F: Fn() -> String {
        println!("calling Fn closure from fn, {}", f());
    }
    
    let a = "Fn".to_string();
    fn_immut(|| a); // 闭包返回一个字符串
}

这样写就会出现上面的那种错误。但如何修复呢?

fn_immut(|| a.clone());

但原因是什么呢?

只要稍稍改下上面的代码,运行一次,编译器给出的错误就很明显了:

fn main() {
    fn fn_immut<F>(f: F) where F: Fn() -> String {
        println!("calling Fn closure from fn, {}", f());
    }
    
    let a = "Fn".to_string();
    let f = || a;
    fn_immut(f);
}

编译器给出的错误如下:

7 |     let f = move || a;
  |             ^^^^^^^^-
  |             |       |
  |             |       closure is `FnOnce` because it moves the variable `a` out of its environment
  |             this closure implements `FnOnce`, not `Fn`
8 |     fn_immut(f);
  |     -------- the requirement to implement `Fn` derives from here

看到没,编译器推导出这个闭包是 FnOnce 类型的,因为闭包最后返回了 a ,交还了所有权,是不能再运行第二次了,因为闭包不再是 a 的所有者。

Fn/FnMut 是被认定可以多次运行的,如果交还了捕获变量的所有权,则下次就不能运行了,所以会报出前面那个错误。

结语

因为闭包和 rust 里的生命周期,所有权紧紧联系在一起了,有时候不怎么好理解,但多写写代码,多试几次,大概就能明白这三者之间的区别。

总之,闭包是 rust 里非常好用的功能,能让代码变得简洁优雅,是值得去学习和掌握的!

No Reply at the moment.
You need to Sign in before reply, if you don't have an account, please Sign up first.