The one thing that sold me on Rust (going from C++) was that there is a single way errors are propagated: the Result type. No need to bother with exceptions, functions returning bool, functions returning 0 on success, functions returning 0 on error, functions returning -1 on error, functions returning negative errno on error, functions taking optional pointer to bool to indicate error (optionally), functions taking r…
unfortunately it's not so simple. that's the convention. depending on the library you're using it might be a special type of Error, or special type of Result, something needs to be transformed, `?` might not work in that case (unless you transform/map it), etc. I like rust, but its not as clean in practice, as you describe
type Result = result::Result;
#[derive(Debug)]
enum MyError {
IOError(String)
// ...
}
Then implement the `From` trait to map errors from third-party libraries to your own custom Error space:
impl From for MyError {
fn from(e: io::Error) -> MyError {
MyError::IOError(e.to_string())
}
}
return sender
.write_all(msg.as_bytes())
.map_err(|e| e.into());