Result Enum

Recoverable errors with Result

enum Result<T, E> {
pub fn generate_nametag_text(name: String) -> Result<String, String> {
    if name.is_empty() {
        // Empty names aren't allowed.
        Err(String::from("`name` was empty; it must be nonempty."))
    } else {
        Ok(format!("Hi! My name is {}", name))


Ok variant indicates the operation was successful, and inside Ok is the successfully generated value.


Err variant means the operation failed, and Err contains information about how or why the operation failed.

? Operator

fn try_to_parse() -> Result<i32, ParseIntError> {
    let x: i32 = "123".parse()?; // x = 123
    let y: i32 = "24a".parse()?; // returns an Err() immediately
    Ok(x + y)                    // Doesn't run.
let res = try_to_parse();
println!("{:?}", res);

Works with Option and Result
unwrap or return Err(From::from(err))

  • Catch-all error
    Under the hood, the ? operator calls From::from on the error value to convert it to a boxed trait object, a Box<dyn error::Error>. This boxed trait object is polymorphic, and since all errors implement the error:Error trait, we can capture lots of different errors in one “Box” object.

Option Enum

fn main() {
	enum Option<T> {
	    None, // NULL Equivalent
let x = Some("air");
assert_eq!(x.unwrap(), "air");
let maybe_name = Some(String::from("Alice"));
// Using `ref`, the value is borrowed, not moved ...
match maybe_name {
    Some(ref n) => println!("Hello, {n}"),
    _ => println!("Hello, world"),
// ... so it's available here!
println!("Hello again, {}", maybe_name.unwrap_or("world".into()));
  • Some()
  • None



expect method can be used in Option or Result to provide user-defined message when in case of panic


At this point, a None/Err(_) value is a programming error and the program is unable to recover from it.