Comment référencer une tranche mutable [dupliquer]

Question

Je veux augmenter une tranche grâce à une référence mutable.

Bien que cela fonctionne avec des tranches immuables:

fn shrink(value: &mut &[u8]) {
    *value = &value[0..2];
}

fn main() {
    let a = [0; 4];
    let mut a_slice: &[u8] = &a;
    shrink(&mut a_slice);
    println!("{:?}", a_slice);
}

Cela ne fonctionne pas avec les mutables:

fn shrink<'a: 'b, 'b>(value: &'a mut &'b mut [u8]) {
    *value = &mut value[0..2];
}

fn main() {
    let mut a = [0; 4];
    let mut a_slice: &mut [u8] = &mut a;
    shrink(&mut a_slice);
    println!("{:?}", a_slice);
}

Message d'erreur:

error[E0502]: cannot borrow `a_slice` as immutable because it is also borrowed as mutable
 --> src/main.rs:8:22
  |
7 |     shrink(&mut a_slice);
  |            ------------ mutable borrow occurs here
8 |     println!("{:?}", a_slice);
  |                      ^^^^^^^
  |                      |
  |                      immutable borrow occurs here
  |                      mutable borrow later used here

Je sais qu'il existe un moyen de mettre à jour la tranche en renvoyant directement une sous-tranche.

Mais existe-t-il un moyen de rendre possible la ré-référence d'une tranche mutable via une référence mutable?

Le problème est similaire à celui-ci , mais je ne peux pas comprendre ce qui le rend si différent, cette solution proposée ne fonctionne pas.

Answer 1

Je ne sais pas quel est le problème avec ce code, mais une option serait de renvoyer directement la tranche mise à jour:

fn shrink(value: &mut [u8]) -> &mut [u8] {
    &mut value[0..2]
}

fn main() {
    let mut a = [0; 4];
    let mut a_slice = &mut a[..];
    a_slice = shrink(a_slice);
    println!("{:?}", a_slice);
}

Plutôt que de mettre à jour via la référence mutable, la mise à jour dans l'appelant indique clairement que l'ancienne valeur de a_slicene sera plus utilisée.