在处理使用 &mut 接收器的嵌套方法调用时，我遇到了一个问题，导致借用检查器错误 . 具体来说，为 Table 结构实现了 deal 函数 . Table 同时包含 players: Vec<Player> 和 deck: Vec<Card> . 在 deal 期间，我试图将卡片从 Table 的 deck 移到 Players s手中 .

struct Card {
    value: u32,
}

struct Player {
    name: String,
    hand: Vec<Card>,
}

struct Table {
    players: Vec<Player>,
    deck: Vec<Card>,
}

impl Card {
    fn new(value: u32) -> Card {
        Card { value: value }
    }
}

impl Player {
    fn new<S>(name: S) -> Player where S: Into<String> {
        Player { name: name.into(), hand: Vec::new() }
    }
}

impl Table {
    fn new(players: Vec<Player>) -> Table {
        let deck = vec![
            Card::new(0),
            Card::new(1),
            Card::new(2),
            Card::new(3),
            Card::new(4),
            Card::new(5),
            Card::new(6),
            Card::new(7),
            Card::new(8),
            Card::new(9),
        ];

        Table { players: players, deck: deck }
    }

    fn deal(&mut self) {
        for player in &mut self.players {
            self.hit(player);
            // Table::hit_b(player, &mut self.deck);
            // player.hand.push(self.deck.pop().unwrap());
        }
    }

    fn hit(&mut self, player: &mut Player) {
        player.hand.push(self.deck.pop().unwrap());
    }

    fn hit_b(player: &mut Player, deck: &mut Vec<Card>) {
        player.hand.push(deck.pop().unwrap());
    }

}

fn main() {
    println!("Simplified Playing Card Implementation");

    // Initialization
    let players = vec![
        Player::new("Player 1"),
        Player::new("Player 2"),
        Player::new("Player 3"),
    ];

    let mut table = Table::new(players);

    // Action
    table.deal();

    // Print
    for player in &table.players {
        print!("{}: ", player.name);
        for card in &player.hand {
            print!("{} ", card.value);
        }
        println!("");
    }
}

error[E0499]: cannot borrow `*self` as mutable more than once at a time
  --> src/main.rs:47:4
   |
46 |            for player in &mut self.players {
   |                               ------------ first mutable borrow occurs here
47 |                    self.hit(player);
   |             ^^^^ second mutable borrow occurs here
48 |                    // player.hand.push(self.deck.pop().unwrap());
49 |            }
   |            - first borrow ends here

我已经实现了几个不同的解决方法，即直接内嵌函数和静态函数，这些函数已被注释掉用于相关代码 . 当然，为了简洁起见，我还没有包含许多其他解决方法 .

是否有一种惯用的方法来解决使用 &mut 接收器的嵌套方法调用问题？可能有一个解决方案可以处理我没有看到的显式生命周期，但我无法完全理解它 .

我还发现了一些相关问题：

顺便说一句，是否有人知道这个设计模式是否会在即将发布的Rust版本中得到解决，可能与MIR的改进有关？

rust