Rust 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 {
        // ...
    }
}
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包裹后，避免了可变性污染的问题，但是也不应该滥用导致可变性限制失去约束力，编码过程中应结合实际情况选择合适的方法。