rust

Rust Best Practices

Crates and Modules

• Use meaningful crate names that reflect their purpose (e.g., auth, config).
• Organize code into modules using the mod keyword and separate files.
• Use pub to expose items to other modules or crates when necessary.
• Manage dependencies with Cargo, specifying versions in Cargo.toml (e.g., serde = "1.0").

Type System

• Use struct for product types to group related data (e.g., struct User { id: u32 }).
• Use enum for sum types to represent variants (e.g., enum Status { Active, Inactive }).
• Define trait to specify behavior and enable polymorphism (e.g., trait Display).
• Use type aliases for clarity with complex types (e.g., type Id = u32).
• Leverage Rust’s ownership and borrowing system for memory safety (e.g., &str vs String).
• Use smart pointers like Box, Rc, or Arc for heap allocation and shared ownership.
• Avoid unnecessary unsafe code; isolate it when required.

Naming Conventions

• Use snake_case for variables and functions (e.g., get_user).
• Use PascalCase for types and traits (e.g., UserService).
• Use SCREAMING_SNAKE_CASE for constants (e.g., MAX_RETRIES).
• Be descriptive yet concise in naming (e.g., user_count over cnt).

Code Organization

• Follow the standard Rust project layout: src/ for source, tests/ for integration tests, examples/ for examples.
• Include modules with mod in lib.rs or main.rs (e.g., mod utils;).
• Use workspaces for multi-crate projects via Cargo.toml (e.g., [workspace]).

Functions and Methods

• Keep functions short and focused on a single responsibility.
• Use early returns with Result or Option for error handling (e.g., if let Some(x) = opt { return x; }).
• Avoid side effects to improve predictability and testability.

Best Practices

• Prefer immutable bindings (let) over mutable ones (let mut) unless mutation is required.
• Use pattern matching for concise, expressive code (e.g., match option { Some(v) => v, None => 0 }).
• Leverage the type system to catch errors at compile time (e.g., via traits and generics).
• Use generics for type-safe, reusable code (e.g., fn process<T: Display>(item: T)).
• Utilize iterators and closures for functional programming (e.g., vec.iter().map(|x| x * 2)).
• Use macros to reduce boilerplate (e.g., macro_rules! log).
• Embrace memory safety features like ownership to prevent bugs.
• Run rustfmt for consistent formatting and clippy for linting (e.g., cargo fmt, cargo clippy).
• Avoid global variables; use lazy_static or once_cell if needed for thread-safe initialization.
• Optimize allocations in performance-critical code with tools like perf or heaptrack.
• Use const fn for compile-time evaluation (e.g., const fn max(a: u32, b: u32) -> u32).
• Check dependencies for vulnerabilities with cargo audit.