Co jest rozwijane w Rust i do czego służy?

Question

Mam ten kod, który wykorzystuje .unwrap():

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

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

    } 
} 

Po patrząc na 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), 
    } 
} 

A signature of read_dir

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

mam rację w zrozumieniu, że unwrap zwraca T typ przekazywany w Result?

Answer 1

w Rust, kiedy masz operację, która może albo powrócić do T lub nie, będzie mieć wartość typu Result<T,E> lub Option<T> (E będzie warunek błędu w przypadku ciekawej błędu).

Funkcja unwrap(self) -> T wyświetli wbudowany T, jeśli taki istnieje. Jeśli zamiast tego nie ma numeru T, ale E lub None, nastąpi panika.

Najlepiej używać go, gdy masz pewność, że nie masz błędu. Jeśli tak nie jest, to zazwyczaj lepiej jest dopasować wzór do błędu lub użyć makra try!, aby przekazać błąd.

W tym przykładzie wywołanie read_dir() zwraca io::Result<ReadDir>, ponieważ otwarcie katalogu może się nie powieść. Iterowanie otwartego katalogu zwraca wiele wartości typu io::Result<DirEntry>, ponieważ odczytanie katalogu może również się nie powieść.

Z try! byłoby coś takiego:

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); 
    } 
} 

Spójrz jak jest zaznaczone każdy przypadek błędu.