use std::panic::{catch_unwind, AssertUnwindSafe};
 
fn risky_operation(divisor: i32) -> i32 {
    100 / divisor  // Will panic if divisor is 0
}
 
fn main() {
    // Successful case
    let result = catch_unwind(|| {
        risky_operation(10)
    });
 
    match result {
        Ok(value) => println!("Calculation succeeded: {}", value),
        Err(e) => println!("Panic occurred: {:?}", e),
    }
 
    // Panic case - divisor is 0
    let panic_result = catch_unwind(|| {
        risky_operation(0)
    });
 
    if panic_result.is_err() {
        println!("Caught panic from division by zero!");
    }
 
    // Using AssertUnwindSafe for shared references
    let shared_data = vec![1, 2, 3];
    let safe_result = catch_unwind(AssertUnwindSafe(|| {
        println!("Processing: {:?}", shared_data);
        42
    }));
 
    println!("Safe result: {:?}", safe_result);
 
    // Practical example: recoverable parsing
    let numbers = vec!["10", "20", "oops", "40"];
    for num_str in numbers {
        let parsed = catch_unwind(|| num_str.parse::<i32>().unwrap());
        match parsed {
            Ok(n) => println!("Parsed: {}", n),
            Err(_) => println!("Failed to parse '{}', continuing...", num_str),
        }
    }
}