concept Result in category rust

appears as: Result, Result
Rust in Action

This is an excerpt from Manning's book Rust in Action.

3.4.2. Making use of the Result return type

Rust’s approach to error handling is to use a type that stands for both the standard case and the error case. This type is known as Result. Result has two states, Ok and Err. This multi-headed hydra is versatile and is put to work all through the standard library. We’ll consider how a single type can act as two later on. For the moment, let’s just investigate the mechanics of working with it.

Listing 3. 13. Using Result to mark functions that are susceptible to file-system errors (ch3/fileresult/src/main.rs)
extern crate rand; #1
use rand::Rng;   #2

fn one_in(n: u32) -> bool {  #3
  rand::thread_rng().gen_weighted_bool(n)
}

#[derive(Debug)]
struct File {
  name: String,
  data: Vec<u8>,
}

impl File {
  fn new(name: &str) -> File {
    File { name: String::from(name), data: Vec::new() }  #4
  }

  fn new_with_data(name: &str, data: &Vec<u8>) -> File {
    let mut f = File::new(name);
    f.data = data.clone();
    f
  }

  fn read(self: &File, save_to: &mut Vec<u8>) -> Result<usize, String> {  #5
    let mut tmp = self.data.clone();
    let read_length = tmp.len();
    save_to.reserve(read_length);
    save_to.append(&mut tmp);
    Ok(read_length)   #6
  }
}

fn open(f: File) -> Result<File, String> {
  if one_in(10_000) {   #7
    let err_msg = String::from("Permission denied");
    return Err(err_msg);
  }
  Ok(f)
}

fn close(f: File) -> Result<File, String> {
  if one_in(100_000) {  #8
    let err_msg = String::from("Interrupted by signal!");
    return Err(err_msg);
  }
  Ok(f)
}

fn main() {
  let f4_data: Vec<u8> = vec![114, 117, 115, 116, 33];
  let mut f4 = File::new_with_data("4.txt", &f4_data);

  let mut buffer: Vec<u8> = vec![];

  f4 = open(f4).unwrap();                         #9
  let f4_length = f4.read(&mut buffer).unwrap();  #9
  f4 = close(f4).unwrap();                        #9

  let text = String::from_utf8_lossy(&buffer);

  println!("{:?}", f4);
  println!("{} is {} bytes long", &f4.name, f4_length);
  println!("{}", text);
}