rust-best-practices

Rust Best Practices

A comprehensive guide to writing idiomatic, safe, and performant Rust code.

Overview

This skill provides best practices for Rust development across five key areas:

1. Ownership & Borrowing - Memory safety without garbage collection
2. Error Handling - Robust error management with Result and Option
3. Async Patterns - Efficient concurrent programming with async/await
4. Testing - Unit, integration, and property-based testing strategies
5. Project Structure - Organizing Rust projects and workspaces

Default Configuration

🚀 ALWAYS USE RUST EDITION 2024 FOR NEW PROJECTS

[package]
name = "my-project"
version = "0.1.0"
edition = "2024"
rust-version = "1.85"  # Minimum required version

For workspaces:

[workspace.package]
edition = "2024"
rust-version = "1.85"

[workspace]
resolver = "2"
members = ["crates/*"]

Why Edition 2024?

• ✅ Native async fn in traits (no more async-trait crate!)
• ✅ if let chains for cleaner pattern matching
• ✅ Return position impl Trait in traits (RPITIT)
• ✅ Improved type inference for closures and iterators
• ✅ Better const fn capabilities for compile-time computation
• ✅ Enhanced error messages with actionable suggestions
• ✅ Improved lifetime elision
• ✅ Better diagnostic attributes

See edition-2024.md for comprehensive Edition 2024 guide including:

• Key features and improvements
• Migration guide from Edition 2021
• Best practices and common patterns
• Performance optimizations
• Security considerations

Core Principles

1. Ownership & Borrowing

Rust's ownership system ensures memory safety at compile time. Follow these principles:

Ownership Rules:

• Each value has a single owner
• When the owner goes out of scope, the value is dropped
• Values can be moved or borrowed (immutably or mutably)

Best Practices:

// ✅ Good: Use references to avoid unnecessary moves
fn process_data(data: &Vec<u8>) {
    // data is borrowed, not moved
    println!("Processing {} bytes", data.len());
}

// ❌ Avoid: Taking ownership when borrowing suffices
fn process_data_bad(data: Vec<u8>) {
    println!("Processing {} bytes", data.len());
    // data is dropped here - caller can't use it anymore
}

// ✅ Good: Use mutable references for in-place modifications
fn append_data(buffer: &mut Vec<u8>, data: &[u8]) {
    buffer.extend_from_slice(data);
}

// ✅ Good: Return owned values when transferring ownership
fn create_buffer(size: usize) -> Vec<u8> {
    vec![0; size]
}