在Rust中实现多重可变（静态分配，静态分派等）回调等价物的正确方法是什么？

Question

我有下面的示例代码，它是其他编程语言中事件驱动的API的标准基础，但在Rust中，借用检查程序阻止它“不能每次多次借用p1作为mutable”：

struct Pen { 
    color_cmyk: u32, 
    ink: usize, 
} 

impl Pen { 
    pub fn new() -> Pen { 
     Pen { 
      color_cmyk: 0x80800000, 
      ink: 20000, 
     } 
    } 

    pub fn write(&mut self, text: &str) -> bool { 
     if self.ink < text.len() { 
      return false; 
     } 

     self.ink -= text.len(); 
     true 
    } 
} 

fn main() { 
    println!("Hello, world !"); 

    let mut p1 = Pen::new(); 
    p1.write("Hello"); 
    println!("ink: {}, color: {}", p1.ink, p1.color_cmyk); 

    let mut cb = |text| if p1.write(text) { 
     println!("{}", text); 
    } else { 
     println!("Out of ink !"); 
    }; 

    let mut cb2 = |text| { 
     p1.write(text); 
     p1.ink 
    }; 

    cb("Hello"); 
    cb("World"); 
    println!("{}", cb2("Hello")); 
} 

error[E0499]: cannot borrow `p1` as mutable more than once at a time 
    --> src/main.rs:37:23 
    | 
31 |   let mut cb = |text| if p1.write(text) { 
    |      ------ -- previous borrow occurs due to use of `p1` in closure 
    |      | 
    |      first mutable borrow occurs here 
... 
37 |   let mut cb2 = |text| { 
    |      ^^^^^^ second mutable borrow occurs here 
38 |    p1.write(text); 
    |    -- borrow occurs due to use of `p1` in closure 
... 
45 |  } 
    |  - first borrow ends here 

该代码可用于，例如，实现两个回调的窗口：一个用于处理键盘事件，而另一个用于处理鼠标事件的，这两者的更新的窗口状态（例如：改变颜色，闭合窗户等）。

我知道，出现在堆栈溢出和其他论坛的其他地方这个问题，但在一般情况下，答案集中在描述问题的原因，很少提出了一个完整的通用解决方案：

• Cannot borrow `x` as mutable more than once at a time
• How to bypass “cannot borrow as mutable more than once”?
• Cannot borrow as mutable more than once at a time
• Passing mutable context into callbacks
• Creating a callback system using closures
• Execute callbacks like as mutable borrowing from cycle
• Callback to mutable self

Answer 1

一种方法是使用RefCell，它允许你发生变异的东西，只有&Pen代替&mut Pen，在推借检查运行时的成本。这很便宜：没有分配，只有一个标志测试。 主要的缺点是违反规则将导致运行时恐慌。一个有用的经验法则是永远不要再借用（认为它们是“单线程互斥体”）。

use std::cell::RefCell; 

fn main() { 
    println!("Hello, world !"); 

    let p1 = RefCell::new(Pen::new()); 
    { 
     let mut rp1 = p1.borrow_mut(); 
     rp1.write("Hello"); 
     println!("ink: {}, color: {}", rp1.ink, rp1.color_cmyk); 
    } 

    let cb = |text| { 
     if p1.borrow_mut().write(text) { 
      println!("{}", text); 
     } 
     else { 
      println!("Out of ink !"); 
     } 
    }; 

    let cb2 = |text| { 
     let mut rp1 = p1.borrow_mut(); 
     rp1.write(text); 
     rp1.ink 
    }; 

    cb("Hello"); 
    cb("World"); 
    println!("{}", cb2("Hello")); 
} 

另一种方法是设置回调系统，将要修改的对象作为参数传入。权衡是那么你的回调系统需要知道这个状态。

fn main() { 
    println!("Hello, world !"); 

    let mut p1 = Pen::new(); 
    p1.write("Hello"); 
    println!("ink: {}, color: {}", p1.ink, p1.color_cmyk); 

    let cb = |p1: &mut Pen, text| if p1.write(text) { 
     println!("{}", text); 
    } else { 
     println!("Out of ink !"); 
    }; 

    let cb2 = |p1: &mut Pen, text| { 
     p1.write(text); 
     p1.ink 
    }; 

    cb(&mut p1, "Hello"); 
    cb(&mut p1, "World"); 
    println!("{}", cb2(&mut p1, "Hello")); 
}