Question

在处理使用&mut接收器的嵌套方法调用时遇到了导致借用检查器错误的问题。具体而言，为deal结构实现了Table函数。 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的改进有关？

使用＆amp; mut接收器的嵌套方法调用会导致借用检查器错误

0 个答案: