如何拥有一个接受另一个变量的闭包调用方法的结构？

debugcn 发表于 Dev

前兔子

因此，这几年我正在编写代码，遇到了一个借用问题：

如何拥有一个接受另一个变量的闭包调用方法的结构？这是我设法提出的最小示例。借用检查器不喜欢两个闭包都借用值。

如果我在值周围有一个互斥锁，那么它似乎可以工作，但是我希望有一个更优雅的解决方案。

本质上，我想让不同的大脑具有不同的输入/输出功能，其中一个可能只是打印输出，另一个可能正在将输出添加到vec。

struct Brain<I, O>
where
    I: Fn() -> i32,
    O: FnMut(i32),
{
    input: I,
    output: O,
}

impl<I, O> Brain<I, O>
where
    I: Fn() -> i32,
    O: FnMut(i32),
{
    fn new(input: I, output: O) -> Self {
        Brain { input, output }
    }
}

fn runner() {
    let mut values = Vec::new();
    let request_input = || *values.last().unwrap();
    let add_output = |v| values.push(v);

    let _ = Brain::new(request_input, add_output);
}

星际战士

您做错了，您显然不能完全做到这一点，您只能拥有一个可变参考或一个或多个参考，但不能同时拥有这两个参考。建议您不要使用特征，而不是使用内部可变性，例如Mutex或Cell：

trait Bus {
    fn input(&self) -> i32;
    fn output(&mut self, v: i32);
}

struct Brain<T>
where
    T: Bus,
{
    bus: T,
}

impl<T> Brain<T>
where
    T: Bus,
{
    fn new(bus: T) -> Self {
        Brain { bus }
    }
}

struct MyBus {
    values: Vec<i32>,
}

impl Bus for MyBus {
    fn input(&self) -> i32 {
        *self.values.last().unwrap()
    }

    fn output(&mut self, v: i32) {
        self.values.push(v)
    }
}

fn main() {
    let bus = MyBus { values: Vec::new() };

    let _ = Brain::new(bus);
}

这提供了很大的灵活性。

本文收集自互联网，转载请注明来源。

如有侵权，请联系[email protected] 删除。