codesnips
rust 13 lines · 1 tab

Pattern matching with match for exhaustive case handling

Marcus Chen Jan 2026
1 tab 
enum Status {
    Ok,
    Error(String),
    Pending,
}

fn handle_status(status: Status) -> String {
    match status {
        Status::Ok => "Success".to_string(),
        Status::Error(msg) => format!("Failed: {}", msg),
        Status::Pending => "Waiting...".to_string(),
    }
}
1 file · rust Explain with highlit

Rust's match expression is like a switch statement on steroids. It requires exhaustive handling of all cases, and the compiler enforces this. You can match on enums, tuples, references, ranges, and destructure nested data. Guards (if condition) add extra filtering. The _ wildcard catches everything else. Because match is an expression, it returns a value, making code more concise. I use match for state machines, parsing, and any branching logic with multiple cases. The exhaustiveness check catches bugs at compile time when you add new enum variants. Combined with pattern destructuring, it's one of Rust's most powerful features for writing correct code.

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
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
rust 
macro_rules! create_function {
    ($func_name:ident) => {
        fn $func_name() {
            println!("Called {}", stringify!($func_name));
        }
    };

Declarative macros (macro_rules!) for code generation

rust macros metaprogramming
by Marcus Chen 1 tab

Share this code

Here's the card — post it anywhere.

Pattern matching with match for exhaustive case handling — share card
Link copied