将所有权与向量解耦

如何解决将所有权与向量解耦

我正在为具有共享引用的对象创建工厂方法。编译器看不到 Vec 中的对象没有在本地范围外被引用，并且新创建的对象没有链接到原始对象。

我该如何解决这个问题，我错过了什么？

#[derive(Debug)]
pub struct A {}

pub struct B<'b> {
    a: &'b A,}

impl<'b> B<'b> {
    pub fn new(a: &'b A) -> B {
        B { a: a }
    }

    pub fn combine(&self,_: &B) -> B {
        B::new(self.a)
    }
}

pub fn main() {
    let a: A = A {};

    let mut v1: Vec<B> = vec![];
    v1.push(B::new(&a));
    v1.push(B::new(&a));

    let mut v2: Vec<B> = vec![];
    {
        let b1 = &v1[0]; // << Mutable borrow occurs here - why?
        let b2 = &v1[1];
        let c = b1.combine(&b2);
        v2.push(c)
    }
    v1.clear(); // Error: Cannot borrow due to mutable borrow above
    println!("{:?}",v2[0].a);
}

error[E0502]: cannot borrow `v1` as mutable because it is also borrowed as immutable
  --> src/main.rs:32:5
   |
27 |         let b1 = &v1[0]; // << Mutable borrow occurs here - why?
   |                   -- immutable borrow occurs here
...
32 |     v1.clear(); // Error: Cannot borrow due to mutable borrow above
   |     ^^^^^^^^^^ mutable borrow occurs here
33 |     println!("{:?}",v2[0].a);
   |                      -- immutable borrow later used here

不，抱歉，我还是不太明白。

这是一个更简单的例子，没有向量：

    let a:A = A {  };
    
    let mut b1 = B::new(&a);
    let mut b2 = B::new(&a);
    
    let c = &b1.combine(&b2);
    //      ^^^ This creates a mutable reference to b1. How to avoid?
    b1 = B::new(&a);
    b2 = B::new(&a);
    
    println!("{:?}",c.a);

出于某种原因，对象上的方法调用将使编译器假定我有对象的引用，尽管 c 没有对 b1 的引用。我该如何解决？

如何将 combine() 方法声明为不可变的？