如何在 Rust 中捕获闭包范围之外的变量？

Question

我正在编写一个不区分大小写的字谜查找器，给定一个单词和一个单词列表。我有以下代码：

pub fn anagrams_for(s: &'static str, v: &[&'static str]) -> Vec<&'static str> {
    let mut s_sorted: Vec<_> = s.to_lowercase().chars().collect();
    s_sorted.sort();

    v.iter().filter_map(move |word: &str| {
        let mut word_sorted: Vec<_> = word.to_lowercase().chars().collect();
        word_sorted.sort();

        if word_sorted == s_sorted && s.to_lowercase() != word.to_lowercase() {
            Some(word)
        } else {
            None
        }
    }).collect()
}

这样做的逻辑是对给定的小写单词进行排序，对于向量中的每个单词，都做同样的事情。如果单词在排序前不同（以消除自字谜）但在排序后是相同的，则将其添加到输出中。

不过，上面似乎在从周围范围捕获s 和s_sorted 时遇到问题，因为当我编译时出现以下错误：

错误：类型不匹配：类型[closure@src/lib.rs:23:25: 32:6 s_sorted:_, s:_] 实现了特征for<'r> core::ops::FnMut<(&'r str,)>，但特征core::ops::FnMut<(&&str,)> 是必需的（预期为&-ptr，找到str）

当我查看此错误类型（[E0281]）的描述时，我发现了以下 TL;DR：

这种情况下的问题是 foo 被定义为接受 Fn 而没有 参数，但我们试图传递给它的闭包需要一个参数。

这很令人困惑，因为我认为 move closures capture variables 来自周围的范围。

我错过了什么？

Answer 1

这与在闭包中捕获变量没有任何关系。让我们再次查看错误消息，重新格式化一下：

type mismatch:
    the type `[closure@<anon>:5:25: 14:6 s_sorted:_, s:_]`
    implements the trait `for<'r> core::ops::FnMut<(&'r str,)>`,
    but the trait `core::ops::FnMut<(&&str,)>` is required
    (expected &-ptr, found str)

更清楚的是：

found:    for<'r> core::ops::FnMut<(&'r str,)>
expected:         core::ops::FnMut<(&&str,)>

进一步放大：

found:    &'r str
expected: &&str

罪魁祸首是：|word: &str|。

你已经声明你的闭包接受一个字符串切片，但是这不是迭代器产生的。 v 是&str 的一个切片，切片上的迭代器返回对切片中项目的引用。每个迭代器元素都是一个&&str。

将您的关闭更改为|&word|，它将起作用。这使用模式匹配在值绑定到word 之前取消引用闭包参数一次。等效地（但不那么惯用），您可以在闭包内使用 |word| 和 *word。

---

另外...

1. 您无需将自己限制为'static 字符串：

   pub fn anagrams_for<'a>(s: &str, v: &[&'a str]) -> Vec<&'a str> {
   

2. 它不需要是 move 闭包。

3. 提取创建排序字符向量的逻辑。这有助于确保逻辑在两个 和 之间保持一致，这意味着您不必将这些向量声明为可变的时间超过所需的时间。

fn sorted_chars(s: &str) -> Vec<char> { 
    let mut s_sorted: Vec<_> = s.to_lowercase().chars().collect();
    s_sorted.sort();
    s_sorted
}

pub fn anagrams_for<'a>(s: &str, v: &[&'a str]) -> Vec<&'a str> {
    let s_sorted = sorted_chars(s);

    v.iter().filter_map(|&word| {
        let word_sorted = sorted_chars(word);

        if word_sorted == s_sorted && s.to_lowercase() != word.to_lowercase() {
            Some(word)
        } else {
            None
        }
    }).collect()
}

fn main() {}

Answer 2

这里的问题是您试图从&&'static str 的序列中创建一个Vec<&'static str>。

pub fn anagrams_for(s: &'static str, v: &[&'static str]) -> Vec<&'static str> {
    let mut s_sorted: Vec<_> = s.to_lowercase().chars().collect();
    s_sorted.sort();

    v.iter().cloned().filter_map(|word: &'static str| {
        let mut word_sorted: Vec<_> = word.to_lowercase().chars().collect();
        word_sorted.sort();

        if word_sorted == s_sorted && s.to_lowercase() != word.to_lowercase() {
            Some(word)
        } else {
            None
        }
    }).collect()
}

cloned 调用是从&&'static str 转到&'static str 所必需的。这是一个廉价的操作，因为 &str 只是一个指向某个 utf8 序列的指针，加上一个长度。

编辑：实际上更好的解决方案是尽可能晚地克隆

v.iter().filter_map(move |word: &&'static str| { // <--- adapted the type to what is actually received
    let mut word_sorted: Vec<_> = word.to_lowercase().chars().collect();
    word_sorted.sort();

    if word_sorted == s_sorted && s.to_lowercase() != word.to_lowercase() {
        Some(word.clone()) // <--- moved clone operation here
    } else {
        None
    }
}).collect()