rust 12 lines · 1 tab

panic! and unwinding for unrecoverable errors

Marcus Chen Jan 2026

1 tab

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

fn main() {
    let result = divide(10, 2);
    println!("Result: {}", result);
    // divide(10, 0); // This would panic
}

1 file · rust Explain with highlit

Rust panics are for bugs, not expected errors. When code panics (via panic!, unwrap(), expect(), or assertion failure), the thread unwinds by default, running destructors. I use panic! for invariant violations or \"this should never happen\" cases. For production, set panic = 'abort' in Cargo.toml to skip unwinding and reduce binary size. Panics can be caught with std::panic::catch_unwind, but this is rare; Rust prefers Result for recoverable errors. I reserve panics for programming errors and use Result for runtime errors. The key is intentionality: panics mean \"the program state is corrupt,\" while Result means \"this operation might fail normally.\"

Related snips

rust

struct Config<'a> {
    name: &'a str,
    value: &'a str,
}

fn parse_config(line: &str) -> Config {

Lifetime annotations for flexible borrowing in structs

rust lifetimes borrowing

by Marcus Chen 1 tab

rust

use crossbeam::channel::unbounded;
use std::thread;

fn main() {
    let (tx, rx) = unbounded();

Crossbeam for advanced concurrent data structures

rust concurrency lock-free

by Marcus Chen 1 tab

javascript

// Creating a Promise
const myPromise = new Promise((resolve, reject) => {
  const success = true;

  setTimeout(() => {
    if (success) {

Promises and async/await patterns for asynchronous JavaScript

javascript promises async-await

by Alex Chang 1 tab

rust

use tracing::{info, instrument};

#[instrument]
fn process_request(user_id: u64) {
    info!(user_id, "Processing request");
    // Work happens here

tracing for structured logging and distributed tracing

rust observability tracing

by Marcus Chen 1 tab

rust

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

Channels (mpsc) for message passing between threads

rust concurrency channels

by Marcus Chen 1 tab

rust

use clap::Parser;

#[derive(Parser, Debug)]
#[command(author, version, about)]
struct Args {
    #[arg(short, long)]

clap for CLI argument parsing with derive macros

rust cli clap

by Marcus Chen 1 tab

Share this code

Here's the card — post it anywhere.

panic! and unwinding for unrecoverable errors — share card

Link copied