Perché un ciclo for non richiede un iteratore mutabile?

Question

Se voglio consumare un iteratore a mano, deve essere mutabile:

let test = vec![1,2,3]; 
let mut test_mut = test.iter(); 
while let Some(val) = test_mut.next() { 
    println!("{:?}",val); 
} 

ma posso tranquillamente consumare con un ciclo for, anche se è immutabile.

let test_imm = test.iter(); 
for val in test_imm { 
    println!("{:?}",val); 
} 

I pare questo funziona all'incirca perché test_imm viene spostato nella per il blocco del ciclo, in modo test_imm non può essere utilizzato dal blocco esterno più ed è (dal punto di vista del blocco esterno) immutabile fino al ciclo for, e quindi è inaccessibile, quindi va bene.

È giusto? C'è altro da spiegare?

Ed: Aha, questo è più o meno spiegato here.

Answer 1

Esattamente. Dal momento che viene spostato nel ciclo for, il ciclo for ora lo possiede e può fare tutto ciò che vuole con esso, incluso "renderlo" mutabile. Considera questo esempio analogo, in cui sembra che si stia mutando xs nonostante sia immutabile, ma in realtà è perché lo stiamo spostando, quindi il nuovo proprietario è libero di farlo con qualsiasi cosa voglia, includendolo nuovamente come mutabile:

let xs: Vec<i32> = vec![1, 2, 3]; 

fn append(v: Vec<i32>, x: i32) -> Vec<i32> { 
    let mut my_v = v; 
    my_v.push(x); 
    my_v 
} 

let appended = append(xs, 4); 

playpen

Nota che la funzione può essere reso più breve utilizzando il parametro di convenienza mut sintassi:

fn append(mut v: Vec<i32>, x: i32) -> Vec<i32> { 
    v.push(x); 
    v 
}