问题背景
来看一个简单的结构体定义：
#[derive(Debug, Default)]
pub struct A {
data: i32,
}
#[derive(Debug, Default)]
pub struct B {
data: i32,
a: A,
}
impl A {
pub fn foo(&self) -> i32 {
// ...
}
}
impl B {
pub fn foo(&self) -> i32 {
let val = self.a.foo();
// ...
}
}
在结构体B中包含了一个结构体A，如果需要在A的foo函数中对A中的变量进行修改，则A中的foo函数需要修改参数为&mut self，此时，B中的foo函数中self.a需要变成&mut，在这种情况下，B中的foo函数参数也需要修改为&mut self。本来只是修改了A的定义，现在却连带B的定义也需要进行修改，这种现象称为self可变性污染。
污染的根源在于底层结构A中的self可变性与高层结构B中的self可变性发生了耦合，一旦底层结构发生可变性修改，必须连带高层结构同时修改。
非耦合场景
非耦合场景中，底层与高层结构均不需要可变性。
#[derive(Debug, Default)]
pub struct A {
data: i32,
}
#[derive(Debug, Default)]
pub struct B {
data: i32,
a: A,
}
impl A {
pub fn foo(&self) -> i32 {
return self.data;
}
}
impl B {
pub fn foo(&self) -> i32 {
let val = self.a.foo();
return val;
}
}
fn main() {
let a = A{data: 123};
let b = B{a: a, data: 234};
println!("before b = {:?}", b);
let result = b.foo(456);
println!("result = {}", result);
println!("after b = {:?}", b);
}
耦合模式实现
底层引入可变性后，连带高层需要加入可变性，同时最顶层的变量也需要加入可变属性。
#[derive(Debug, Default)]
pub struct A {
data: i32,
}
#[derive(Debug, Default)]
pub struct B {
data: i32,
a: A,
}
impl A {
pub fn foo(&mut self, data: i32) -> i32 {
self.data = data;
return self.data;
}
}
impl B {
pub fn foo(&mut self, data: i32) -> i32 {
let val = self.a.foo(data);
return val;
}
}
fn main() {
let a = A{data: 123 };
let mut b = B{a: a, data: 234};
println!("before b = {:?}", b);
let result = b.foo(789);
println!("result = {}", result);
println!("after b = {:?}", b);
}
上面仅仅展示了一个简单的结构体引用的场景，如果这个结构体引用层次较多，或者包含了其他crate中定义的结构，这种可变性污染将是个灾难性的难题。
为了避免可变性污染，需要将结构体间的引用解耦开，使得底层定义的修改仅限于内部完成，一旦发生修改，仅修改特定的定义即可，这个场景，正符合内部可变性的应用范围。
包裹模式实现
use std::cell::RefCell;
use std::rc::Rc;
#[derive(Debug, Default)]
pub struct A {
data: i32,
}
#[derive(Debug, Default)]
pub struct B {
data: i32,
a: Rc<RefCell<A>>,
}
impl A {
pub fn foo(&mut self, data: i32) -> i32 {
self.data = data;
return self.data;
}
}
impl B {
pub fn foo(&self, data: i32) -> i32 {
let val = self.a.borrow_mut().foo(data);
return val;
}
}
fn main() {
let a = A{data: 123};
let b = B{a: Rc::new(RefCell::new(a)), data: 234};
println!("before b = {:?}", b);
let result = b.foo(789);
println!("result = {}", result);
println!("after b = {:?}", b);
}
通过使用Rc<RefCell<T>>的包裹，在A中进行的修改与B本身的可变性无关，在B中通过borrow_mut获取到A的引用，后续的修改仅与A本身相关。
总结
在Rust中，由于可变性的限制，结构体引用是一个会导致极大复杂度的设计方法，为了避免可变性的污染，应该尽量使得结构体内部的引用之间解耦开，使得有逻辑依赖的结构体可以独立的进行修改。
在解耦之后，需要使用borrow，match等手段才能取到被包裹的原始内容，可能会带来一定的复杂性，但是相比语义污染而言，这种方法不失为一种更加优秀的设计模式。
使用RefCell包裹后，避免了可变性污染的问题，但是也不应该滥用导致可变性限制失去约束力，编码过程中应结合实际情况选择合适的方法。
