The panic! macro in Rust is used to signal that your program is in a state it can't handle and should terminate immediately. This is typically used in cases where there is an unrecoverable error, such as trying to access memory that doesn't exist or dividing by zero.
How to cause a panic in practice?
There are two ways to cause a panic in practice:
- By taking an action that causes our code to panic: This could be something like trying to access an array past the end or dividing by zero. When the Rust compiler detects one of these kinds of errors, it will automatically call the panic! macro.
- By explicitly calling the panic! macro: You can also call the panic! macro explicitly to signal that your program is in an unrecoverable state. This is typically done in cases where you have detected an error that you cannot recover from, such as a missing file or a corrupted database.
What happens when you call panic!?
When you call the panic! macro, Rust will unwind the stack and clean up any resources that were allocated by the current thread. Then, it will print a failure message and terminate the program.
Example
Here is a simple example of how to use the panic! macro:
fn main() {
// Try to access an array element that doesn't exist.
let my_array = [1, 2, 3];
println!("{}", my_array[3]); // This will cause a panic.
}
When you run this program, you will see the following output:
thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 3', src/main.rs:2:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
The first line of the output shows the error message and the place in the source code where the panic occurred. The second line tells you that you can run the program with the RUST_BACKTRACE=1 environment variable to display a backtrace of the functions that were called leading up to the panic.
When to use panic!?
The panic! macro should only be used in cases where there is an unrecoverable error. If you can recover from an error, you should use the Result enum instead.
