Ndtyjky

Currently, I'm turning a Result into an instance of my error enum that impls Fail like this:

fn bbswitch_write(data: &str) -> Result<(), BbswitchError> {

    match fs::write("/proc/acpi/bbswitch", data) {

        Ok(_) => Ok(()),

        Err(e) => Err(BbswitchError::BbswitchNotAvailable { cause: e }.into()),

    }

}

but this feels very verbose, and I'd rather not write a four-line match statement every time I do something like this:

let contents = fs::read_to_string("/proc/acpi/bbswitch").expect("bbswitch not available");

Is there something I'm doing wrong that's making error handling unreasonably difficult, or a way I could structure something better to make it more convenient?

The rest of my code looks something like this:

#[macro_use]

extern crate failure;



use std::fs;

use std::process::exit;

use failure::Error;



#[derive(Debug, Fail)]

enum BbswitchError {

    #[fail(display = "bbswitch not available")]

    BbswitchNotAvailable {

        #[fail(cause)]

        cause: std::io::Error,

    },

}



fn bbswitch_write(data: &str) -> Result<(), Error> {

    match fs::write("/proc/acpi/bbswitch", data) {

        Ok(_) => Ok(()),

        Err(e) => Err(BbswitchError::BbswitchNotAvailable { cause: e }.into()),

    }

}



fn power_on() -> Result<(), Error> {

    bbswitch_write("ON")?;

    Ok(())

}



fn main() {

    match power_on() {

        Ok(_) => {},

        Err(_) => exit(1),

    }

}

That very simple just use map_err():

fs::write("/proc/acpi/bbswitch", data)

    .map_err(|e| BbswitchError::BbswitchNotAvailable { cause: e }.into())