返回一个改变其环境的闭包

Question

我正在编写一个简单的程序，它遍历目录、读取其条目并生成 JSON 结构。当我试图返回一个改变捕获的&mut Vec 参数的闭包时遇到了麻烦：

use std::io;
use std::fs::{self, DirEntry,};
use std::path::Path;

extern crate rustc_serialize;
use rustc_serialize::json;


// json encoding: 
#[derive(Debug, RustcEncodable)]
struct Doc {
    path: String,
    filename: String,
}


fn main() {
    let target_path = Path::new("/Users/interaction/workspace/temp/testeddocs");
    let mut docs: Vec<Doc> = Vec::new();

    fn create_handler(docs: &mut Vec<Doc>) -> &FnMut(&DirEntry) {
        let handler = |entry: &DirEntry| -> () {
            let doc = Doc {
                path: entry.path().to_str().unwrap().to_string(),
                filename: entry.file_name().into_string().unwrap(),
            };
            docs.push(doc);
        };

        &handler
    }
    {
        let handler = create_handler(&mut docs);
        visit_dirs(&target_path, & |entry: &DirEntry|{
            handler(entry);
        });
    }
    println!("result json is: {}", json::encode(&docs).unwrap());
}

// one possible implementation of walking a directory only visiting files
fn visit_dirs(dir: &Path, cb: &Fn(&DirEntry)) -> io::Result<()> {
    if try!(fs::metadata(dir)).is_dir() {
        for entry in try!(fs::read_dir(dir)) {
            let entry = try!(entry);
            if try!(fs::metadata(entry.path())).is_dir() {
                try!(visit_dirs(&entry.path(), cb));
            } else {
                cb(&entry);
            }
        }
    }
    Ok(())
}

这是它给出的编译器错误：

error: cannot borrow immutable borrowed content `***handler` as mutable
--> src/main.rs:36:13
   |
36 |             handler(entry);
   |             ^^^^^^^

error[E0373]: closure may outlive the current function, but it borrows `docs`, which is owned by the current function
--> src/main.rs:23:23
   |
23 |         let handler = |entry: &DirEntry| -> () {
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^ may outlive borrowed value `docs`
...
28 |             docs.push(doc);
   |             ---- `docs` is borrowed here
   |
help: to force the closure to take ownership of `docs` (and any other referenced variables), use the `move` keyword, as shown:
|         let handler = move |entry: &DirEntry| -> () {

error: `handler` does not live long enough
--> src/main.rs:31:10
   |
31 |         &handler
   |          ^^^^^^^ does not live long enough
32 |     }
   |     - borrowed value only lives until here
   |
note: borrowed value must be valid for the anonymous lifetime #1 defined on the block at 22:64...
--> src/main.rs:22:65
   |
22 |     fn create_handler(docs: &mut Vec<Doc>) -> &FnMut(&DirEntry) {
   |

Answer 1

问题

如果你仔细看create_handler，你会发现handler会在函数结束时被销毁，因为它只是一个局部变量。因此，Rust 禁止任何可能从函数外部使用的对 handle 的引用。否则，引用将指向不再可用的数据（经典的悬空指针错误）。

解决方案 1：装箱

您可以通过装箱（在堆上分配）将闭包作为特征对象返回。这是在稳定的 Rust (1.14) 中做到这一点的唯一方法：

fn create_handler(docs: &mut Vec<Doc>) -> Box<FnMut(&DirEntry)> {
    let handler = |entry: &DirEntry| -> () {
        let doc = Doc {
            path: entry.path().to_str().unwrap().to_string(),
            filename: entry.file_name().into_string().unwrap(),
        };
        docs.push(doc);
    };

    Box::new(handler)
}

方案二：按值返回闭包

虽然这在稳定的 Rust (1.14) 中不起作用，但您可以在夜间使用它。这种方法的好处是它避免了堆分配：

fn create_handler(docs: &mut Vec<Doc>) -> impl FnMut(&DirEntry) {
    let handler = |entry: &DirEntry| -> () {
        let doc = Doc {
            path: entry.path().to_str().unwrap().to_string(),
            filename: entry.file_name().into_string().unwrap(),
        };
        docs.push(doc);
    };

    handler
}

Answer 2

经过几天的摸索，我想我已经找到了解决方案，通过利用 Box 和 move（move + Box 不要创建深度克隆）。

但这并不如我所愿，因为我必须更改visit_dirs签名（那段代码是从rust doc复制的，所以我不想更改它）。如果有人有更好的建议，请告诉我。

致@ker 和@aochagavia，感谢您的帮助，非常感谢。

use std::io;
use std::fs::{self, DirEntry,};
use std::path::Path;

extern crate rustc_serialize;
use rustc_serialize::json;


// json encoding: 
#[derive(Debug, RustcEncodable)]
struct Doc {
    path: String,
    filename: String,
}


fn main() {
    let target_path = Path::new("/Users/interaction/workspace/temp/testeddocs");
    let mut docs: Vec<Doc> = Vec::new();

    fn create_handler<'a>(docs: &'a mut Vec<Doc>) -> Box<FnMut(&DirEntry) + 'a> {
        let handler = move |entry: &DirEntry| -> () {
            let doc = Doc {
                path: entry.path().to_str().unwrap().to_string(),
                filename: entry.file_name().into_string().unwrap(),
            };
            docs.push(doc);
        };

        Box::new(handler)
    }

    {
        let mut handler = create_handler(&mut docs);
        visit_dirs(&target_path, &mut |entry: &DirEntry|{
            handler(entry)
        });
    }
    println!("result json is: {}", json::encode(&docs).unwrap());
}

// one possible implementation of walking a directory only visiting files
fn visit_dirs(dir: &Path, cb: &mut FnMut(&DirEntry)) -> io::Result<()> {
    if try!(fs::metadata(dir)).is_dir() {
        for entry in try!(fs::read_dir(dir)) {
            let entry = try!(entry);
            if try!(fs::metadata(entry.path())).is_dir() {
                try!(visit_dirs(&entry.path(), cb));
            } else {
                cb(&entry);
            }
        }
    }
    Ok(())
}