Rust Development

Expert knowledge for modern systems programming with Rust, focusing on memory safety, fearless concurrency, and zero-cost abstractions.

Core Expertise

Modern Rust Ecosystem

• Cargo: Build system, package manager, and workspace management

• Rustc: Compiler optimization, target management, and cross-compilation

• Clippy: Linting for idiomatic code and performance improvements

• Rustfmt: Consistent code formatting following Rust style guidelines

• Rust-analyzer: Advanced IDE support with LSP integration

Language Features

• Rust 2024 edition: RPITIT, async fn in traits, impl Trait improvements

• Const generics and compile-time computation

• Generic associated types (GATs)

• Let-else patterns and if-let chains

Key Capabilities

Ownership & Memory Safety

• Implement ownership patterns with borrowing and lifetimes

• Design zero-copy abstractions and efficient memory layouts

• Apply RAII patterns through Drop trait and smart pointers (Box, Rc, Arc)

• Leverage interior mutability patterns (Cell, RefCell, Mutex, RwLock)

• Use Pin/Unpin for self-referential structures

Async Programming & Concurrency

• Tokio: Async runtime for high-performance network applications

• async-std: Alternative async runtime with familiar API design

• Futures: Composable async abstractions and stream processing

• Rayon: Data parallelism with work-stealing thread pools

• Design lock-free data structures with atomics and memory ordering

Error Handling & Type Safety

• Design comprehensive error types with thiserror and anyhow

• Implement Result<T, E> and Option patterns effectively

• Use pattern matching for exhaustive error handling

• Apply type-state patterns for compile-time guarantees

Performance Optimization

• Profile with cargo-flamegraph, perf, and criterion benchmarks

• Optimize with SIMD intrinsics and auto-vectorization

• Implement zero-cost abstractions and inline optimizations

• Use unsafe code judiciously with proper safety documentation

Testing & Quality Assurance

• Unit Testing: #[test] modules with assertions

• Integration Testing: tests/ directory for end-to-end validation

• Criterion: Micro-benchmarking with statistical analysis

• Miri: Undefined behavior detection in unsafe code

• Fuzzing: cargo-fuzz for security and robustness testing

Essential Commands

Project setup

cargo new my-project # Binary crate cargo new my-lib --lib # Library crate cargo init # Initialize in existing directory

Development workflow

cargo build # Debug build cargo build --release # Optimized build cargo run # Build and run cargo run --release # Run optimized cargo test # Run all tests cargo test --lib # Library tests only cargo bench # Run benchmarks

Code quality

cargo clippy # Lint code cargo clippy -- -W clippy::pedantic # Stricter lints cargo fmt # Format code cargo fmt --check # Check formatting cargo fix # Auto-fix warnings

Dependencies

cargo add serde --features derive # Add dependency cargo update # Update deps cargo audit # Security audit cargo deny check # License/advisory check

Advanced tools

cargo expand # Macro expansion cargo flamegraph # Profile with flame graph cargo doc --open # Generate and open docs cargo miri test # Check for UB

Cross-compilation

rustup target add wasm32-unknown-unknown cargo build --target wasm32-unknown-unknown

Best Practices

Idiomatic Rust Patterns

// Use iterators over manual loops let sum: i32 = numbers.iter().filter(|x| **x > 0).sum();

// Prefer combinators for Option/Result let value = config.get("key") .and_then(|v| v.parse().ok()) .unwrap_or_default();

// Use pattern matching effectively match result { Ok(value) if value > 0 => process(value), Ok(_) => handle_zero(), Err(e) => return Err(e.into()), }

// Let-else for early returns let Some(config) = load_config() else { return Err(ConfigError::NotFound); };

Project Structure

my-project/ ├── Cargo.toml ├── src/ │ ├── lib.rs # Library root │ ├── main.rs # Binary entry point │ ├── error.rs # Error types │ └── modules/ │ └── mod.rs ├── tests/ # Integration tests ├── benches/ # Benchmarks └── examples/ # Example programs

Error Handling

use thiserror::Error;

#[derive(Error, Debug)] pub enum AppError { #[error("IO error: {0}")] Io(#[from] std::io::Error),

#[error("parse error: {message}")]
Parse { message: String },

#[error("not found: {0}")]
NotFound(String),

}

pub type Result<T> = std::result::Result<T, AppError>;

Common Crates

Crate Purpose

serde

Serialization/deserialization

tokio

Async runtime

reqwest

HTTP client

sqlx

Async SQL

clap

CLI argument parsing

tracing

Logging/diagnostics

anyhow

Application errors

thiserror

Library errors

For detailed async patterns, unsafe code guidelines, WebAssembly compilation, embedded development, and advanced debugging, see REFERENCE.md.