rust 14 lines · 1 tab

Borrowing with & and &mut for zero-cost access

Marcus Chen Jan 2026

1 tab

fn calculate_length(s: &String) -> usize {
    s.len()
}

fn append_suffix(s: &mut String) {
    s.push_str(" world");
}

fn main() {
    let mut text = String::from("hello");
    let len = calculate_length(&text);
    append_suffix(&mut text);
    println!("{} (length was {})", text, len);
}

1 file · rust Explain with highlit

Instead of transferring ownership, Rust lets you borrow values with references (&T for immutable, &mut T for mutable). Borrows allow functions to read or modify data without taking ownership, so the caller retains access afterward. The borrow checker enforces that you can have either many immutable borrows or one mutable borrow at a time, preventing data races. This is enforced at compile time with zero runtime cost. I use immutable borrows for read-only operations and mutable borrows when I need to modify in place. The lifetime annotations ensure references never outlive the data they point to. This pattern is pervasive in Rust APIs and enables safe concurrency without locks in many cases.

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.

Borrowing with & and &mut for zero-cost access — share card

Link copied