rust 8 lines · 1 tab

Result and ? operator for clean error propagation

Marcus Chen Jan 2026

1 tab

use std::fs;
use std::num::ParseIntError;

fn read_port(path: &str) -> Result<u16, Box<dyn std::error::Error>> {
    let contents = fs::read_to_string(path)?;
    let port: u16 = contents.trim().parse()?;
    Ok(port)
}

1 file · rust Explain with highlit

Rust's Result<T, E> forces you to handle errors explicitly, but the ? operator makes it ergonomic. When a function returns Result, using ? automatically returns early with the error if it's Err, or unwraps the value if it's Ok. This replaces verbose match or unwrap() chains. The key is that ? only works in functions that return Result or Option, which keeps error handling explicit at boundaries. I use this everywhere: file I/O, parsing, network calls. It reads sequentially like exceptions but without hidden control flow. The compiler ensures you can't ignore errors, and the calling code decides how to handle them. This is one of Rust's killer features for reliability.

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.

Result and ? operator for clean error propagation — share card

Link copied