从可变自函数调用可变自函数

Question

在下面的示例中，我想为每个简单的spin smol_socket_handle调用usize。

pub fn spin_all(&mut self) -> u8 {
        for (smol_socket_handle, _) in self.smol_sockets.iter_mut() {
            self.spin(smol_socket_handle.clone());
        }
        0
    }
pub fn spin(&mut self, smol_socket_handle: usize) -> u8 {

问题是我借用了两次可变的self。当spin_all被调用时，我们再一次调用spin。我绝对需要spin在&mut self上工作。如何使spin_all为可变的self多次调用spin

更新：

所以如果我正确理解了，

    for (smol_socket_handle, smol_socket) in self.smol_sockets.iter_mut() {
        self.spin(smol_socket_handle.clone());
    }

扩展成

{
    //borrows self mutably
    let mut _iter = std::iter::IntoIterator::into_iter(self.smol_sockets.iter_mut());
    loop {
        match _iter.next() {
            Some(loop_variable) => {
                //tries to borrow self mutably again while it's still borrowed into `_iter`
                self.spin(loop_variable.clone());
            },
            None => break,
        }
    }
}

Answer 1

的问题是，我借自己变了两次。当spin_all被调用时，当我们再一次调用自旋时。

不这不是问题所在。可变的&mut self of spin_all被spin重用，没有冲突(实际上，它不会在其他情况下工作，因为self.spin将尝试从不可变的借款中创建可变的借款，这将失败)。

问题是，您正在为self.smol_sockets.iter_mut()创建一个可变的借入，而为self.spin()创建一个单独的和重叠的借款。

您应该像Aloso所指出的那样，通过克隆套接字来避免在可迭代套接字上借入，或者给spin一个索引/键到迭代中，这样它就可以在内部借款。

Answer 2

对我来说，最简单的答案是在第二个函数中声明可变的借用。如果foo调用bar，则在bar内部执行可变的借用，而不是向bar传递可变的引用，这是行不通的。

这样做：

pub fn foo(&mut self, thingid: u32) {
    //stuff
    self.bar(&thingid);
}
pub fn bar(&mut self, thingid: u32) {
    self.things.get_mut(&thingid).unwrap();
    //stuff
}

不要这样做，因为它会导致错误(error[E0502]: cannot borrow *self as immutable because it is also borrowed as mutable)。

pub fn foo(&mut self, thingid: u32) {
    //stuff
    let thing = self.things.get_mut(&thingid).unwrap();
    self.bar(thing);
}
pub fn bar(&mut self, thing: &mut Thing) {
    //stuff
}