Rust 使用Rc<；FnMut>；作为一个FnMut

给定一个

Rc

，在迭代器上映射时如何使用它？例如：

use std::rc::Rc;

fn main() {
    let f = Rc::new(|x| x);
    let v = vec![1, 2, 3];
    let _: Vec<_> = v.into_iter().map(f).collect();
}

---

啊

try_unwrap

将为您提供对闭包的移动访问，而

*f

将为您提供对闭包的引用

因此，解决方案可以是：

use std::rc::Rc;

fn main() {
    let f = Rc::new(|x| x);
    let v = vec![1, 2, 3];
    match Rc::try_unwrap(f) {
        Ok(f2) => {
            let _: Vec<_> = v.into_iter().map(f2).collect();
        }
        _ => ()
    }
}

使用std:：rc:：rc；
fn main（）{
设f=Rc:：new（| x | x）；
设v=vec！[1,2,3]；
匹配Rc：：尝试展开（f）{
Ok（f2）=>{
让u:Vec=v.进入iter（）.map（f2.collect（）；
}
_ => ()
}
}

---

（虽然可能有更干净的方法）直接传递

f

不起作用，因为

Rc其中t:FnMut

没有实现

FnMut

fn main() {
    let mut f = Box::new(|x| x);
    let v = vec![1, 2, 3];
    let _: Vec<_> = v.into_iter().map(&mut *f).collect();
}

如果你的闭包没有执行任何变异（即它实现了

Fn

），你可以改为写

&*f

。这是因为：

Rc

实现，它改变了

*

操作符的行为，使得

*x

扩展为

*（x.deref（））

，从而允许我们访问包装的闭包

*

运算符生成一个左值，允许您引用结果

对实现

Fn

FnMut

的类型的不可变引用

虽然它看起来不像一个，但实际上（从Rust 1.23开始）扩展到了

f.call（（v，）

（注意，这种语法是不稳定的，因此如果启用了

fn_traits

功能，只有每晚编译的编译器才会接受它）

---

如果闭包在

框中，则可以编写
&mut*f
，因为
框
实现了
DerefMut

fn main() {
    let mut f = Box::new(|x| x);
    let v = vec![1, 2, 3];
    let _: Vec<_> = v.into_iter().map(&mut *f).collect();
}

fn main（）{
设mut f=Box:：new（|x | x）；
设v=vec！[1,2,3]；
让u:Vec=v.进入iter（）.map（&mut*f）.collect（）；
}
您几乎不想使用
Rc:：get_mut
或
Rc:：make_mut
FnMut
需要可变访问；如果您需要对共享值的可变访问，则需要一个锁定概念。常见的模式有
Rc
和
Arc
——但是
FnMut
（以及大多数其他特性）不会自动实现，因为您需要处理锁故障。您几乎永远不想使用
Rc:：try_unwrap
；这会消耗
Rc
，只有在没有其他共享所有者的情况下才起作用。如果您有一个匹配臂，您可以在let

use std::rc::Rc;

fn main() {
    let f = Rc::new(|x| x);
    let v = vec![1, 2, 3];
    let _: Vec<_> = v.into_iter().map(|v| f(v)).collect();
}

fn main() {
    let mut f = Box::new(|x| x);
    let v = vec![1, 2, 3];
    let _: Vec<_> = v.into_iter().map(&mut *f).collect();
}