How do I tell the compiler that my function terminates the program like process::exit()?

Question

I have the following function that includes some error recovery logic and the process::exit(0) in the end:

fn gracefully_shutdown() {
    // Do some logic for the recover
    process::exit(7);
}

I want to call that function in the error case but match complains about incompatible arms. But it does not complain when I write it explicitly into a match arm like the following:

fn handle_result(my_result: Result<i32, MyError>) -> i32 {
    match my_result {
        Ok(val) => val,
        //Err(_error) => { process::exit(0); } // Does not complain
        Err(_error) => {
            gracefully_shutdown();
        } // Does complain
    }
}

Is it really hard for the compiler to understand that gracefully_shutdown() contains process::exit(0) in itself?

I would expect that I could have written the code in this way:

fn handle_result(my_result: Result<i32, MyError>) -> i32 {
    match my_result {
        Ok(val) => val,
        Err(_error) => {
            gracefully_shutdown();
        }
    }
}

Any ideas to make this work?

Playground

Answer 1

Change the signature of gracefully_shutdown to

fn gracefully_shutdown() -> ! {
    process::exit(7);
}

This will tell the compiler that this function never returns! The ! is called the never type.

For more information see

• Why does Rust have a "Never" primitive type?