Perché è possibile implementare Read su un riferimento immutabile a File?

Question

Se si controlla lo docs for Read, la maggior parte dei metodi accetta uno &mut self. Ciò ha senso, poiché la lettura da qualcosa di solito aggiorna un offset interno in modo che la lettura successiva restituisca dati diversi. Tuttavia, questo compila:

use std::io::Read; 
use std::fs::File; 

fn main() { 
    let file = File::open("/etc/hosts").unwrap(); 
    let vec = &mut Vec::new(); 
    (&file).read_to_end(vec).unwrap(); 
    println!("{:?}", vec); 
} 

Il file non è mutevole, ma i dati sono certamente in corso la lettura in questo sembra non corretto per me.. It was pointed out that there is an impl<'a> Read for &'a File, ma il fatto che un'istanza immutabile sia apparentemente mutata sembra ancora strano.

Answer 1

Come indicato da @kennytm, a.read_to_end(vec) equivale a Read::read_to_end(&mut a, vec), quindi (&file).read_to_end(vec) si espande a Read::read_to_end(&mut &file, vec). Nell'ultima espressione, &file è un nuovo valore temporaneo di tipo &File. Non c'è alcun problema nel prendere riferimenti mutabili a un'espressione (ad esempio &mut 42). Questo è esattamente quello che succede qui. Il fatto che l'espressione sia un riferimento a un valore immutabile non ha importanza perché non possiamo effettivamente mutare il valore tramite uno &mut &T.

Per quanto riguarda la questione del perché non abbiamo bisogno del File di essere mutevole: File è fondamentalmente solo un descrittore di file newtyped, vale a dire un indice in una tabella open-file che viene gestito dal sistema operativo. read e gli amici non cambieranno affatto questo descrittore, ed è per questo che lo File non ha bisogno di essere modificato. Ovviamente c'è una mutazione, ma il sistema operativo si basa sulle proprie strutture dati e non sul codice ruggine dell'utente.