fn divide(a: i32, b: i32) -> i32 {
    if b == 0 {
        panic!("division by zero: cannot divide {} by 0", a);
    }
    a / b
}

fn main() {
    let result = divide(10, 0); // triggers panic
    println!("{}", result);     // never reached
}

fn main() {
    // Out-of-bounds panic
    let v = vec![1, 2, 3];
    // println!("{}", v[10]); // panics: index out of bounds: the len is 3 but the index is 10

    // unwrap on None
    let name: Option<&str> = None;
    // name.unwrap(); // panics: called `Option::unwrap()` on a `None` value

    // unwrap on Err
    let n: Result<i32, _> = "abc".parse::<i32>();
    // n.unwrap(); // panics: called `Result::unwrap()` on an `Err` value

    // expect with a custom message
    let x: Option<i32> = None;
    // x.expect("x must have a value here"); // panics: x must have a value here
}

# Linux / macOS
RUST_BACKTRACE=1 cargo run

# Windows PowerShell
$env:RUST_BACKTRACE=1; cargo run

# Windows cmd
set RUST_BACKTRACE=1 && cargo run

enum Direction { North, South, East, West }

fn compass_degrees(d: &Direction) -> u32 {
    match d {
        Direction::North => 0,
        Direction::South => 180,
        Direction::East  => 90,
        Direction::West  => 270,
    }
}

fn parse_direction(s: &str) -> Direction {
    match s {
        "N" => Direction::North,
        "S" => Direction::South,
        "E" => Direction::East,
        "W" => Direction::West,
        _   => panic!("invalid direction string: {:?}", s),
    }
}

fn future_feature() -> String {
    todo!("implement this in the next sprint")
}

trait Animal {
    fn name(&self) -> &str;
    fn sound(&self) -> &str {
        unimplemented!("this animal makes no sound")
    }
}

struct Cat;
impl Animal for Cat {
    fn name(&self) -> &str { "cat" }
    fn sound(&self) -> &str { "meow" }
}

fn show(dir: &Direction) {
    // This arm is logically unreachable given our parse_direction above
    let degrees = compass_degrees(dir);
    if degrees > 360 {
        unreachable!("compass degrees are always 0..=360");
    }
    println!("{}°", degrees);
}

# Cargo.toml

[profile.release]
panic = "abort"   # smaller binary, no unwinding overhead in production

[profile.dev]
panic = "unwind"  # default — run Drop impls, required for catch_unwind

use std::panic;

fn risky_operation(x: i32) -> i32 {
    if x < 0 {
        panic!("negative input not allowed: {}", x);
    }
    x * 2
}

fn main() {
    let result = panic::catch_unwind(|| risky_operation(-5));

    match result {
        Ok(value) => println!("success: {}", value),
        Err(_)    => println!("caught a panic — the thread is still alive"),
    }

    println!("program continues normally after caught panic");

    // A second call that succeeds
    let ok = panic::catch_unwind(|| risky_operation(10));
    println!("second call: {}", ok.unwrap()); // 20
}

fn parse_positive(s: &str) -> u32 {
    let n: i32 = s.parse().expect("not a number");
    if n <= 0 {
        panic!("value must be positive, got {}", n);
    }
    n as u32
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn valid_input_works() {
        assert_eq!(parse_positive("42"), 42);
    }

    #[test]
    #[should_panic(expected = "value must be positive")]
    fn negative_input_panics() {
        parse_positive("-5");
    }

    #[test]
    #[should_panic]
    fn non_numeric_panics() {
        parse_positive("hello");
    }
}

use std::panic;

fn main() {
    panic::set_hook(Box::new(|info| {
        let location = info.location().map_or(
            "unknown location".to_string(),
            |l| format!("{}:{}", l.file(), l.line()),
        );

        let message = if let Some(s) = info.payload().downcast_ref::<&str>() {
            s.to_string()
        } else if let Some(s) = info.payload().downcast_ref::<String>() {
            s.clone()
        } else {
            "unknown panic payload".to_string()
        };

        // Could write to a file or a crash reporter here
        eprintln!("[CRASH] {} — {}", message, location);
    }));

    panic!("something went very wrong");
}

use std::panic::{self, AssertUnwindSafe};

fn main() {
    let mut counter = 0u32;

    // &mut u32 is not UnwindSafe — wrap it with AssertUnwindSafe
    let result = panic::catch_unwind(AssertUnwindSafe(|| {
        counter += 1;
        panic!("mid-mutation panic");
    }));

    // counter was incremented before the panic fired
    println!("caught: {}", result.is_err()); // true
    println!("counter after panic: {}", counter); // 1 — partially mutated
}