Rust Systems Programming Patterns

Description

A comprehensive guide to production Rust patterns for 2026. Covers ownership and borrowing mental models, error handling with thiserror/anyhow, async concurrency with Tokio, web services with Axum, database access (SQLx, Diesel, SeaORM), CLI development, WebAssembly, and Python bindings via PyO3. Targets Rust Edition 2024 (1.85.0+).

Usage

Install this skill to get production-ready Rust patterns including:

• Ownership, borrowing, and lifetime rules with concrete mental models
• thiserror vs anyhow selection guide for libraries vs applications
• Tokio runtime patterns: spawn, select!, streams
• Axum web server: routing, extractors, middleware, shared state
• Concurrency primitives: Arc, Mutex, RwLock, channels, Rayon

When working on Rust projects, this skill provides context for:

• Deciding when to clone vs borrow vs move
• Structuring async code to avoid blocking the event loop
• Choosing between database libraries based on project needs
• Building CLI tools with Clap v4 derive API
• Creating Python extension modules with PyO3

Key Patterns

Ownership Mental Model

Think of ownership like a title deed:

• Move (let y = x): You transfer the deed. x is no longer valid.
• Immutable borrow (&T): Multiple readers simultaneously, no modifications.
• Mutable borrow (&mut T): One exclusive borrower who can modify. No others inside.

rust
1// Quick pattern reference
2fn risky() -> Result<T, E> {
3    let x = operation()?;  // ? operator: early return on error
4    Ok(x)
5}
6
7// Shared mutable state across threads
8let data = Arc::new(Mutex::new(vec![]));
9let clone = Arc::clone(&data);
10tokio::spawn(async move { clone.lock().unwrap().push(1); });

Error Handling: thiserror vs anyhow

Use anyhow for applications (add context to error chains):

rust
1use anyhow::{Result, Context};
2
3fn main() -> Result<()> {
4    let data = std::fs::read_to_string("user.json")
5        .context("could not read user.json")?;
6    Ok(())
7}

Tokio Async Patterns

rust
1// Multi-threaded runtime
2#[tokio::main(flavor = "multi_thread", worker_threads = 4)]
3async fn main() { ... }
4
5// Race futures: select! picks the first to complete
6let winner = tokio::select! {
7    result = slow_future() => result,
8    result = fast_future() => result,
9    _ = tokio::time::sleep(Duration::from_secs(5)) => "timeout",
10};
11
12// Blocking code inside async: use spawn_blocking
13let data = tokio::task::spawn_blocking(|| {
14    std::fs::read_to_string("file.txt")
15}).await.unwrap();

Anti-pattern: blocking sync I/O inside async fn. Use tokio::fs instead of std::fs.

Axum Web Server

rust
1use axum::{Router, routing::{get, post}, Json, http::StatusCode};
2use std::sync::Arc;
3
4#[derive(Clone)]
5struct AppState { db_url: String }
6
7async fn create_user(Json(user): Json<User>) -> (StatusCode, Json<User>) {
8    (StatusCode::CREATED, Json(user))
9}
10
11#[tokio::main]
12async fn main() {
13    let state = Arc::new(AppState { db_url: "postgres://...".into() });
14    let app = Router::new()
15        .route("/users", post(create_user))
16        .with_state(state);
17    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
18    axum::serve(listener, app).await.unwrap();
19}

Concurrency Primitives

rust
1// Arc<Mutex<T>>: shared mutable state across threads
2let counter = Arc::new(Mutex::new(0));
3for _ in 0..10 {
4    let c = Arc::clone(&counter);
5    thread::spawn(move || { *c.lock().unwrap() += 1; });
6}
7
8// RwLock: multiple readers OR one writer
9let data = Arc::new(RwLock::new(vec!["a", "b"]));
10let read = data.read().unwrap();   // shared read
11let write = data.write().unwrap(); // exclusive write
12
13// Rayon: parallel iterators (automatic work-stealing)
14use rayon::prelude::*;
15let sum: u64 = (1..=1_000_000).collect::<Vec<_>>().par_iter().sum();

Prefer channels over Arc<Mutex> for message-passing patterns.

Clap v4 CLI (Derive API)

rust
1use clap::{Parser, Subcommand};
2
3#[derive(Parser)]
4#[command(name = "myapp", about = "My CLI tool")]
5struct Cli {
6    #[arg(short, long)] verbose: bool,
7    #[command(subcommand)] command: Commands,
8}
9
10#[derive(Subcommand)]
11enum Commands {
12    Process { #[arg(short, long)] format: String },
13    Download { url: String },
14}

Anti-Patterns to Avoid

Tools & References

• The Rust Book
• Tokio Tutorial
• Axum Docs
• PyO3 Docs
• cargo add tokio --features full - async runtime
• cargo add axum serde serde_json - web + serialization
• cargo add thiserror anyhow - error handling

Published by MidOS — MCP Community Library