rust-optimise

Original：🇺🇸 English

Translated

Rust performance optimization covering memory allocation, ownership efficiency, data structure selection, iterator patterns, async concurrency, algorithm complexity, compile-time optimization, and micro-optimizations. Use when optimizing Rust code performance, profiling hot paths, reducing allocations, or choosing optimal data structures. Complements the rust-refactor skill (idiomatic patterns and architecture). Does NOT cover code style, naming conventions, or project organization (see rust-refactor skill).

1installs

Sourcepproenca/dot-skills

Added on2026-02-14

NPX Install

npx skill4agent add pproenca/dot-skills rust-optimise

SKILL.md Content

View Translation Comparison →

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-

Priority	Category	Impact	Prefix
1	Memory Allocation	CRITICAL	`mem-`
2	Ownership & Borrowing	CRITICAL	`own-`
3	Data Structure Selection	HIGH	`ds-`
4	Iterator & Collection Patterns	HIGH	`iter-`
5	Async & Concurrency	MEDIUM-HIGH	`async-`
6	Algorithm Complexity	MEDIUM	`algo-`
7	Compile-Time Optimization	MEDIUM	`comp-`
8	Micro-optimizations	LOW	`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

Related Skills

For idiomatic patterns, architecture, and code organization, see
```
rust-refactor
```
skill