Занимать элементы mut в векторе

Question

Я пытаюсь воспроизвести следующий код Go в Rust:

func (s *State) GetTargets() []*wrestler.Wrestler {
    targets := make([]*wrestler.Wrestler, len(s.Targets))
    for i, n := range s.Targets {
        targets[i] = s.Players[n]
    }
    return targets
}

В Rust у меня есть следующая попытка воспроизвести метод Go:

pub struct State<'a> {
    targets: Vec<usize>,
    players: Vec<Wrestler<'a>>,
}

#[derive(Debug)]
pub struct Wrestler<'a> {
    name: &'a str,
}

impl<'a> State<'a> {
    pub fn targets(&mut self) -> Vec<&mut Wrestler<'a>> {
        let mut wrestlers = vec![];
        for t in self.targets.iter() {
            let w = self.players.get_mut(*t).unwrap();
            wrestlers.push(w);
        }
        wrestlers
    }
}

fn main() {
    let s = State {
        targets: vec![0, 1],
        players: vec![Wrestler { name: "Test1" }, Wrestler { name: "Test2" }],
    };

    println!("{:?}", s.targets());
}

детская площадка

Я не могу одолжить self.players многократно; Я получаю следующие ошибки:

error[E0499]: cannot borrow `self.players` as mutable more than once at a time
  --> src/main.rs:15:21
   |
15 |             let w = self.players.get_mut(*t).unwrap();
   |                     ^^^^^^^^^^^^ mutable borrow starts here in previous iteration of loop
...
19 |     }
   |     - mutable borrow ends here

error[E0596]: cannot borrow immutable local variable `s` as mutable
  --> src/main.rs:28:22
   |
23 |     let s = State {
   |         - consider changing this to `mut s`
...
28 |     println!("{:?}", s.targets());
   |                      ^ cannot borrow mutably

Знаете ли вы, как решить эту проблему? Я все еще изучаю Rust, так что, хотя это, вероятно, очевидно для вас, это все еще сбивает меня с толку.

Я прочитал следующий пост: Как получить изменяемые ссылки на два элемента массива одновременно?

Кажется, что решение использует split_at_mut, но в моем случае это не работает. Посмотрите:

pub fn targets(&mut self) -> Vec<&mut Wrestler<'a>> {
    let mut wrestlers = vec![];
    for t in self.targets.iter() {
        let (_, r) = self.players.split_at_mut(*t);
        let w = r.get_mut(0).unwrap();
        wrestlers.push(w);
    }
    wrestlers
}

@trentcl найти решение, которое выглядит так:

pub fn targets(&mut self) -> Vec<&mut Wrestler<'a>> {
    let mut wrestlers = vec![];
    for t in self.targets.iter() {
        let w = &mut self.players[*t] as *mut _;
        // Safe because we know that *t is always different and therefore
        // *w is always distinct from all the previous iterations. (The
        // API must guarantee that self.targets never contains duplicates)
        wrestlers.push(unsafe { &mut *w });
    }
    wrestlers
}

Но я не понимаю следующую строку: &mut self.players[*t] as *mut _И почему это &mut *w в небезопасных {}. Но спасибо trentcl за решение.