Unrecoverable Errors with panic!

In Rust, errors are broadly categorized into two types: recoverable and unrecoverable. Recoverable errors are those that you can anticipate and respond to, often by retrying an operation or informing the user. Rust handles these using the `Result<T, E>` enum. Unrecoverable errors, on the other hand, are typically indicative of a bug in your code or a state where it's impossible for the program to continue safely.

The `panic!` macro is Rust's primary mechanism for handling unrecoverable errors. When `panic!` is called, your program will print a failure message, unwind the stack (cleaning up data on the stack as it goes), and then exit. This process can be configured to 'abort' instead of 'unwind' in the `Cargo.toml` by setting `panic = "abort"` for a smaller binary size, but this means memory is not cleaned up by Rust before exiting.

When to use `panic!`:
* Bugs: When your program reaches an impossible state or violates an invariant that should never be broken. For example, accessing an array out of bounds (though Rust's indexing usually checks this at runtime and panics automatically). If a library function's contract is violated by the caller, panicking is often appropriate.
* Prototypes and Tests: During development, you might use `panic!` for conditions that you intend to handle more gracefully later but want to ensure are caught immediately.
* Unrecoverable States: If a critical dependency fails in a way that makes continued operation impossible or unsafe (e.g., a required configuration file is corrupt and there's no default or fallback).

What happens during a `panic!`:
1. The `panic!` macro is executed.
2. A panic hook (which can be customized) is called. By default, this hook prints the panic message and the location where the panic occurred.
3. The program starts unwinding the stack, dropping resources (e.g., calling `drop` for `Box`, `Vec`, etc.) as it goes up the call stack.
4. If the unwinding completes, the program exits with a non-zero status code.

Backtraces:
When a `panic!` occurs, Rust can provide a 'backtrace' that shows the sequence of function calls that led to the panic. This is invaluable for debugging. You can enable backtraces by setting the `RUST_BACKTRACE` environment variable to `1` before running your program:
`RUST_BACKTRACE=1 cargo run`

Important Considerations:
* Libraries vs. Applications: In general, it's recommended that libraries avoid panicking for conditions that a user of the library might reasonably expect and want to handle (e.g., invalid input). Instead, libraries should return `Result<T, E>`. Applications, however, have more leeway because they control the entire execution environment.
* Performance: Unwinding the stack can have a performance cost. If your application frequently enters states that would cause a panic, it might indicate a design flaw that could be better handled with `Result`.
* Error Handling Strategy: While `panic!` is for unrecoverable errors, the general Rust philosophy encourages robust error handling using `Result` for anticipated failures.

```rust
fn divide(numerator: f64, denominator: f64) -> f64 {
    if denominator == 0.0 {
        // This is an unrecoverable error in this context because
        // division by zero is mathematically undefined and we don't
        // have a meaningful 'Result' to return for it here that makes sense.
        // A real application might return a Result or handle it differently
        // depending on the domain, but for illustrating panic!, this works.
        panic!("Cannot divide by zero! Denominator was 0.0");
    }
    numerator / denominator
}

fn access_element(arr: &[i32], index: usize) -> i32 {
    // Rust's default array indexing will panic if out of bounds,
    // but we can also explicitly panic for illustrative purposes.
    if index >= arr.len() {
        panic!("Index out of bounds! Array length is {} but index was {}", arr.len(), index);
    }
    arr[index]
}

fn main() {
    println!("--- Demonstrating panic! with division ---");
    let result = divide(10.0, 2.0);
    println!("10 / 2 = {}", result);

    // This call will cause a panic!
    println!("Attempting to divide by zero...");
    // Uncomment the line below to see the panic in action.
    // let _ = divide(10.0, 0.0);
    // println!("This line will not be reached if the above panics.");

    println!("\n--- Demonstrating panic! with array access ---");
    let my_array = [10, 20, 30];
    println!("Array element at index 0: {}", access_element(&my_array, 0));
    println!("Array element at index 2: {}", access_element(&my_array, 2));

    // This call will cause a panic!
    println!("Attempting to access array out of bounds...");
    // Uncomment the line below to see the panic in action.
    // let _ = access_element(&my_array, 5);
    // println!("This line will not be reached if the above panics.");

    println!("\nProgram finished successfully (if panic lines were commented out).");
    println!("To see panics, uncomment the `divide(10.0, 0.0)` or `access_element(&my_array, 5)` lines.");
    println!("To see backtrace, run with: RUST_BACKTRACE=1 cargo run");
}
```