Result<T,E> en Rust

· ĝisdatigita · #rust

En mia unua enigmo de la defio Advent of Code mi uzis iom da kopiita kaj algluita Rust-kodo, kiun mi ne tute komprenis… Jam tempas kompreni la kodon kaj priskribi ĝin ĉi tie.

Temas pri la metodoj .expect kaj .unwrap().

File::open() en la kopiita kodo kaŭzas kompilan eraron sen .expect()

File::open(filename).expect("error message");

La funkcio parse en la kopiita kodo kaŭzas kompilan eraron sen voko de .unwrap()

line.parse::<i32>().unwrap();

El la signaturo de std::fs::File::open() mi vidas, ke ĝi redonas ne File, sed Result<File>. Guglado kondukas al la ĉapitro Error Handling en la Rust Book, kiu klarigas:

Rust ne havas esceptojn. Anstataŭe ĝi havas la tipon Result<T, E> por ripareblaj eraroj kaj la makroon panic!, kiu haltigas la plenumon, kiam la programo renkontas neripareblan eraron.

Result<T, E> estas la tipo uzata por redoni kaj plusendi erarojn. Ĝi estas enumeracio kun la variantoj Ok(T), kiu reprezentas sukceson kaj enhavas valoron, kaj Err(E), kiu reprezentas eraron kaj enhavas erarvaloron.

La ĝenerala enumeracio Result aspektas jene:

enum Result<T, E> {
   Ok(T),
   Err(E),
}

Ricevinte rezulton, la programisto devas trakti ambaŭ kazojn: Ok(result) kaj Err(why). Tipa erartraktado en Rust aspektas jene:

use std::fs::File;
use std::error::Error;

fn main() {
    let path = ".gitignore";
    match File::open(&path) {
        Err(why) => panic!("couldn't open {}: {}", path, why.description()),
        Ok(file) => println!("{:?}", file),
    };
}

Jen kiel la Rust Book klarigas la supran kodon:

Kiam File::open sukcesas, la valoro en [la konstruaĵo match] estos instanco de Ok, kiu enhavas dosiertenilon. Kiam ĝi malsukcesas, la valoro en [la konstruaĵo match] estos instanco de Err, kiu enhavas pliajn informojn pri la speco de la okazinta eraro.

Depende de la rezulto de la operacio, plenumiĝos nur unu branĉo.

Do kio estas la celo de .expect() en ĉi tiu kodo?

File::open(filename).expect("error message");

Mi rigardas la dokumentaron de std::result::Result kaj vidas jenan klarigon:

Elpakas rezulton, liverante la enhavon de Ok. Panikas, se la valoro estas Err, kun panikmesaĝo, kiu inkluzivas la transdonitan mesaĝon, kaj la enhavon de Err.

Do esence .expect() estas mallongigo de la supra konstruaĵo match. Ĝi aŭ prenas la rezulton, aŭ panikas kun mesaĝo. Mi kontrolis la kodon de std::result::Result kaj vidas jenon:

  #[inline]
  #[stable(feature = "result_expect", since = "1.4.0")]
  pub fn expect(self, msg: &str) -> T {
      match self {
          Ok(t) => t,
          Err(e) => unwrap_failed(msg, e),
      }
  }

Tre simile al la ekzemplo kun kongruigo de Result, kiun mi donis supre.

Ankoraŭ unu noto el la Rust Book:

Rust grupigas erarojn en du ĉefajn kategoriojn: ripareblaj kaj neripareblaj eraroj. Ĉe riparebla eraro, ekzemple kiam dosiero ne troviĝas, estas racie raporti la problemon al la uzanto kaj reprovi la operacion. Nerepareblaj eraroj ĉiam estas simptomoj de cimoj, ekzemple provo aliri lokon trans la fino de tabelo.

.expect() faras el riparebla eraro neripareblan. En simplaj kazoj estas akcepteble trakti la situacion tiel, sed produktaj programoj ne paniku, se dosiero mankas aŭ ne estas legebla.

.unwrap() tre similas al .expect:

Elpakas rezulton, liverante la enhavon de Ok. Panikas, se la valoro estas Err, kun panikmesaĝo provizita de la valoro de Err.

Do la sola diferenco estas, ke expect akceptas aldonan erarmesaĝon.

Plia legaĵo:


Averto