Rust lang series episode #2 4 — user error types (#rust-series)
Hello everyone, new episode of rust series is here, today we will close Error handling in Rust. We will finish our error handling sub-series with user error types and brief summary.
Content
- From trait
- Implementing own Error types
- Boxed Error and String error type
- Summary
From trait
From trait is very usefull and it's also used by try! macro that we discussed before to convert one error type to another.
trait From<T> {
fn from(T) -> Self;
}
Implementing own Error type
We will implement our user error type enum MyError and will work with that.
use std::io;
use std::fs::File;
use std::io::prelude::*;
use std::io::{Error, ErrorKind};
#[derive(Debug)]
enum MyError {
FileWriteError
}
impl From<io::Error> for MyError {
fn from(e: io::Error) -> MyError {
MyError::FileWriteError
}
}
fn do_some_io() -> Result<i32, MyError> {
let original_error = Err(io::Error::new(ErrorKind::Other, "Fake IO error"));
match original_error {
Ok(v) => v,
Err(e) => {
Err(From::from(e))
}
}
}
fn main() {
let res = do_some_io();
match res {
Ok(v) => println!("{}", v),
Err(err) => {
println!("my_error: {:?}", err);
}
}
}
# output
my_error: FileWriteError
Simplified version with try!
We can simplify do_some_io function with try! macro significantly
fn do_some_io() -> Result<i32, MyError> {
let original_error = Err(io::Error::new(ErrorKind::Other, "Fake IO error"));
try!(original_error)
}
Boxed Error
If you want to simplify your work you can also use Box<Error> construction where
conversion works just fine for you. Let's see this example.
use std::io;
use std::error::Error;
fn do_some_io() -> Result<i32, Box<Error>> {
let original_error = io::Error::new(io::ErrorKind::Other, "Fake IO error");
Err(From::from(original_error))
}
fn main() {
let res = do_some_io();
match res {
Ok(v) => println!("{}", v),
Err(err) => {
println!("my_error: {:?}", err);
}
}
}
# output
my_error: Error { repr: Custom(Custom { kind: Other, error: StringError("Fake IO error") }) }
Boxed String error type
You can also simply construct our won StringError that can be passed further as Box<Error>
use std::error::Error;
fn do_some_io() -> Result<i32, Box<Error>> {
Err(From::from("fake IO error occured"))
}
fn main() {
let res = do_some_io();
match res {
Ok(v) => println!("{}", v),
Err(err) => {
println!("my_error: {:?}", err);
}
}
# output
my_error: StringError("fake IO error occured")
Summary of error handling
Error handling can be performed in various ways, let's list them from most simple approach to the most complex one.
- panic!
- unwrap()
- String or Box error type
- Own type, From and std::error::Error
- Combinators (map, and_then, map_err, ...)
Congratulations! If you have passed all four episodes you should understand Rust error handling fundamentals. Now you just need to practice.
Postfix
That's all for handling, thank you for your appreciations, feel free to comment and point out possible mistakes (first 24 hours works the best but any time is fine). May Jesus bless your programming skills, use them wisely and see you next time.
Meanwhile you can also check the official documentation for more details if you wish.