Come posso creare due nuove sezioni mutabili da una sezione?

Question

Vorrei prendere una sezione mutabile e copiare il contenuto in due nuove sezioni mutabili. Ogni fetta è metà dell'originale.

Il mio tentativo # 1:

let my_list: &mut [u8] = &mut [0, 1, 2, 3, 4, 5]; 
let list_a: &mut [u8] = my_list[0..3].clone(); 
let list_b: &mut [u8] = my_list[3..6].clone(); 
println!("{:?}", my_list); 
println!("{:?}", list_a); 
println!("{:?}", list_b); 

uscita:

error: no method named `clone` found for type `[u8]` in the current scope 
--> src/main.rs:3:43 
    | 
3 |  let list_a: &mut [u8] = my_list[0..3].clone(); 
    |           ^^^^^ 

error: no method named `clone` found for type `[u8]` in the current scope 
--> src/main.rs:4:43 
    | 
4 |  let list_b: &mut [u8] = my_list[3..6].clone(); 
    |           ^^^^^ 

Il mio tentativo # 2:

let my_list: &mut [u8] = &mut [0, 1, 2, 3, 4, 5]; 
let list_a: &mut [u8] = my_list[0..3].to_owned(); 
let list_b: &mut [u8] = my_list[3..6].to_owned(); 
println!("{:?}", my_list); 
println!("{:?}", list_a); 
println!("{:?}", list_b); 

uscita:

error[E0308]: mismatched types 
    --> src/main.rs:12:29 
    | 
12 |  let list_a: &mut [u8] = my_list[0..3].to_owned(); 
    |        ^^^^^^^^^^^^^^^^^^^^^^^^ expected &mut [u8], found struct `std::vec::Vec` 
    | 
    = note: expected type `&mut [u8]` 
       found type `std::vec::Vec<u8>` 
    = help: try with `&mut my_list[0..3].to_owned()` 

error[E0308]: mismatched types 
    --> src/main.rs:13:29 
    | 
13 |  let list_b: &mut [u8] = my_list[3..6].to_owned(); 
    |        ^^^^^^^^^^^^^^^^^^^^^^^^ expected &mut [u8], found struct `std::vec::Vec` 
    | 
    = note: expected type `&mut [u8]` 
       found type `std::vec::Vec<u8>` 
    = help: try with `&mut my_list[3..6].to_owned()` 

Posso usare due Vec<u8> e proprio loop all'interno di ingresso e di spingere i valori clonati credo, ma speravo ci fosse un modo più bello per fare questo:

extern crate rand; 

use rand::{thread_rng, Rng}; 

fn main() { 
    let my_list: &mut [u8] = &mut [0; 100]; 
    thread_rng().fill_bytes(my_list); 
    let list_a = &mut Vec::new(); 
    let list_b = &mut Vec::new(); 
    for i in 0..my_list.len() { 
     if i < my_list.len()/2 { 
      list_a.push(my_list[i].clone()); 
     } else { 
      list_b.push(my_list[i].clone()); 
     } 
    } 
    println!("{:?}", list_a.as_slice()); 
    println!("{:?}", list_b.as_slice()); 
    println!("{:?}", my_list); 
} 

Answer 1

È possibile costruire vettori da fette direttamente clonando gli elementi utilizzando diversi metodi:

1. Vec::to_vec
2. From/Into
3. ToOwned

fn main() { 
    let my_list: &mut [u8] = &mut [0, 1, 2, 3, 4, 5]; 
    let mut vec1 = my_list[0..2].to_vec(); 
    let mut vec2: Vec<u8> = my_list[2..4].into(); 
    let mut vec3 = my_list[2..6].to_owned(); 

    println!("{:?}", vec1); 
    println!("{:?}", vec2); 
} 

Il tuo problema originale è stato causato perché tutti questi restituiscono un Vec ma si stavano cercando di affermare che si trattava di una fetta, pari a:

let thing: &mut [u8] = Vec::new(); 

Answer 2

Si potrebbe catena due iteratori oltre le fette.

let my_list: &mut [u8] = &mut [0, 1, 2, 3, 4, 5]; 
let mut slices = my_list[0..3].iter().chain(my_list[3..6].iter()); 
for e in slices {} 

chain sarà iterare il primo iteratore, poi il secondo.

Per creare nuove liste:

let my_list: &mut [u8] = &mut [0, 1, 2, 3, 4, 5]; 
let mut a: Vec<u8> = my_list[0..3].iter().cloned().collect(); 
let mut b: Vec<u8> = my_list[3..6].iter().cloned().collect(); 

Answer 3

Il split_at e split_at_mut metodi daranno voi due fette, che potete poi copiare o anche usare tranquillamente senza copiare se il controllo del prestito lo consente.

let (list_a, list_b) = my_list.split_at_mut(my_list.len()/2)