rust-expert

Rust Expert

Fight the design, not the borrow checker — a borrow error is usually a real aliasing/lifetime problem. Make invalid states unrepresentable, return errors as values, and reach for clone()/unsafe deliberately, never to silence the compiler.

When to Use

• Writing or refactoring Rust.
• Borrow-checker, lifetime, move/clone, or Send/Sync errors.
• Designing traits, generics, error types, or APIs.
• Async (tokio), iterators, smart pointers, or vetting unsafe.

When NOT to Use

• Other languages → the relevant language skill.
• High-level system architecture → software-architect.

Core Principles

1. Ownership & borrowing by design

• Borrow (&T/&mut T) over cloning; clone() is a real cost you choose, not an error silencer.
• The rule: many &T xor one &mut T. When it fights you, restructure: narrow scopes, split borrows, index-based access, or interior mutability (Cell/RefCell single-thread, Mutex/RwLock multi-thread).
• Params take &str/&[T]/impl AsRef<_>; store owned String/Vec<T>. Return owned data or borrow tied to an input lifetime.

2. Errors are values

• Return Result<T, E>; propagate with ?. Avoid unwrap()/expect() outside tests, main, or provably-infallible spots (and then expect() with a reason).
• Libraries: typed errors with thiserror (impl std::error::Error, use #[from]). Apps: anyhow::Result with .context("…").
• Option for absence, Result for failure. Don't panic on recoverable conditions.

3. Model with the type system

• Enums to make illegal states unrepresentable; newtype pattern for domain values and to add trait impls.
• Generics + trait bounds by default; dyn Trait (boxed) for heterogeneous collections, plugin points, or smaller code size. Derive Debug/Clone/PartialEq where sensible; impl From for conversions so ? composes.

4. Async & concurrency

• Pick one runtime (usually tokio). Never block the executor — use async I/O; offload CPU/blocking work to spawn_blocking or a thread pool.
• Share state with Arc<Mutex<T>>/Arc<RwLock<T>>; hold locks for the shortest possible scope and never across .await. Move ownership across tasks via channels.