Che cosa è unwrap in Rust e a cosa serve?

Question

Ho questo codice che utilizza .unwrap():

fn main() { 
    let paths = std::fs::read_dir("/home/user").unwrap(); 

    for path in paths { 
     println!("Name: {}", path.unwrap().path().display()); 

    } 
} 

Dopo aver guardato il definition of unwrap,

pub fn unwrap(self) -> T { 
    match self { 
     Ok(t) => t, 
     Err(e) => unwrap_failed("called `Result::unwrap()` on an `Err` value", e), 
    } 
} 

E il signature of read_dir

pub fn read_dir<P: AsRef<Path>>(path: P) -> io::Result<ReadDir> 

Ho ragione nel capire che unwrap restituisce il T digitare che viene passato in Result?

Answer 1

In ruggine, quando si ha un funzionamento che può restituire un T o sicuro, si avrà un valore di tipo Result<T,E> o Option<T> (E sarà la condizione di errore in caso di errore interessante).

La funzione unwrap(self) -> T fornisce lo T incorporato se ce n'è uno. Se invece non c'è uno T ma uno E o None allora andrà nel panico.

Si utilizza preferibilmente quando si è sicuri che non si sia verificato un errore. In caso contrario, è meglio che il modello corrisponda all'errore o utilizzi la macro try! per inoltrare l'errore.

Nell'esempio, la chiamata a read_dir() restituisce un io::Result<ReadDir> perché l'apertura della directory potrebbe non riuscire. E l'iterazione della directory aperta restituisce più valori di tipo io::Result<DirEntry> perché anche la lettura della directory potrebbe non riuscire.

Con try! sarebbe qualcosa di simile:

fn main2() -> std::io::Result<()> { 
    let paths = try!(std::fs::read_dir("/home/user")); 

    for path in paths { 
     println!("Name: {}", try!(path).path().display()); 

    } 
    Ok(()) 
} 

fn main() { 
    let res = main2(); 

    if let Err(e) = res { 
     println!("Error: {}", e); 
    } 
} 

Guarda come tutti i casi di errore viene controllato.