Rust Optimise Best Practices

Performance optimization guide for Rust applications. Contains 42 rules across 8 categories, prioritized by impact from critical (memory allocation, ownership) to incremental (micro-optimizations).

When to Apply

• Optimizing Rust code for performance or reducing allocations
• Choosing data structures for optimal algorithmic complexity
• Working with iterators to avoid unnecessary intermediate allocations
• Writing async code with Tokio or other runtimes
• Profiling hot paths and eliminating performance bottlenecks
• Reviewing code for performance anti-patterns

Rule Categories by Priority

mem-

own-

ds-

iter-

async-

algo-

comp-

micro-

Quick Reference

1. Memory Allocation (CRITICAL)

• mem-avoid-unnecessary-clone

  - Avoid unnecessary clone calls

• mem-preallocate-vec-capacity

  - Preallocate Vec capacity

• mem-use-cow-for-conditional-ownership

  - Use Cow for conditional ownership

• mem-use-arc-for-shared-immutable-data

  - Use Arc for shared immutable data

• mem-avoid-format-for-simple-concatenation

  - Avoid format! for simple concatenation

• mem-use-smallvec-for-small-collections

  - Use SmallVec for small collections

2. Ownership & Borrowing (CRITICAL)

• own-accept-str-slice-not-string

  - Accept &str instead of &String

• own-accept-slice-not-vec

  - Accept &[T] instead of &Vec<T>

• own-use-into-for-flexible-ownership

  - Use Into<T> for flexible ownership

• own-return-borrowed-when-possible

  - Return borrowed data when possible

• own-use-asref-for-generic-borrows

  - Use AsRef<T> for generic borrows

3. Data Structure Selection (HIGH)

• ds-use-hashset-for-membership

  - Use HashSet for membership tests

• ds-use-hashmap-for-key-lookup

  - Use HashMap for key-value lookups

• ds-use-btreemap-for-sorted-iteration

  - Use BTreeMap for sorted iteration

• ds-use-vecdeque-for-queue-operations

  - Use VecDeque for queue operations

• ds-use-entry-api-for-conditional-insert

  - Use Entry API for conditional insert

4. Iterator & Collection Patterns (HIGH)

• iter-chain-instead-of-intermediate-collect

  - Chain iterators instead of intermediate collect

• iter-use-iter-over-into-iter-when-borrowing

  - Use iter() over into_iter() when borrowing

• iter-use-filter-map-for-combined-operations

  - Use filter_map for combined operations

• iter-use-flat-map-for-nested-iteration

  - Use flat_map for nested iteration

• iter-use-extend-for-bulk-append

  - Use extend() for bulk append

• iter-use-fold-for-accumulation

  - Use fold() for complex accumulation

5. Async & Concurrency (MEDIUM-HIGH)

• async-avoid-blocking-in-async-context

  - Avoid blocking in async context

• async-use-join-for-concurrent-futures

  - Use join! for concurrent futures

• async-use-rwlock-over-mutex-for-read-heavy

  - Use RwLock over Mutex for read-heavy

• async-minimize-lock-scope

  - Minimize lock scope

• async-use-buffered-for-bounded-concurrency

  - Use buffered() for bounded concurrency

• async-avoid-holding-lock-across-await

  - Avoid holding lock across await

6. Algorithm Complexity (MEDIUM)

• algo-avoid-nested-loops-for-lookup

  - Avoid nested loops for lookups

• algo-use-binary-search-for-sorted-data

  - Use binary search for sorted data

• algo-use-sort-unstable-when-order-irrelevant

  - Use sort_unstable when order irrelevant

• algo-use-select-nth-unstable-for-partial-sort

  - Use select_nth_unstable for partial sort

• algo-use-chunks-for-batch-processing

  - Use chunks() for batch processing

7. Compile-Time Optimization (MEDIUM)

• comp-use-const-for-compile-time-computation

  - Use const for compile-time computation

• comp-prefer-static-dispatch

  - Prefer static dispatch over dynamic

• comp-reduce-monomorphization-bloat

  - Reduce monomorphization bloat

• comp-use-const-generics-for-array-sizes

  - Use const generics for array sizes

• comp-avoid-repeated-parsing-of-static-data

  - Avoid repeated parsing of static data

8. Micro-optimizations (LOW)

• micro-use-inline-for-small-functions

  - Apply inline attribute to small hot functions

• micro-avoid-bounds-checks-in-hot-loops

  - Avoid bounds checks in hot loops

• micro-use-wrapping-arithmetic-when-safe

  - Use wrapping arithmetic when safe

• micro-use-byte-literals-for-ascii

  - Use byte literals for ASCII

References

1. https://nnethercote.github.io/perf-book/
2. https://rust-lang.github.io/api-guidelines/
3. https://doc.rust-lang.org/nomicon/
4. https://tokio.rs/tokio/tutorial

Related Skills

• For idiomatic patterns, architecture, and code organization, see

  rust-refactor

  skill