1# Common Rust Anti-Patterns & Mistakes
2 
3## Ownership Anti-Patterns
4 
5### 1. Clone Everything
6 
7```rust
8// ANTI-PATTERN: clone to avoid borrow checker
9fn process(data: Vec<String>) {
10    for item in data.clone() {  // unnecessary clone
11        println!("{}", item);
12    }
13    use_data(data);
14}
15 
16// BETTER: borrow when you don't need ownership
17fn process(data: Vec<String>) {
18    for item in &data {  // borrow instead
19        println!("{}", item);
20    }
21    use_data(data);
22}
23```
24 
25### 2. Unnecessary Box
26 
27```rust
28// ANTI-PATTERN: boxing everything
29fn get_value() -> Box<String> {
30    Box::new(String::from("hello"))
31}
32 
33// BETTER: return value directly
34fn get_value() -> String {
35    String::from("hello")
36}
37```
38 
39### 3. Holding References Too Long
40 
41```rust
42// ANTI-PATTERN: borrow prevents mutation
43let mut data = vec![1, 2, 3];
44let first = &data[0];
45data.push(4);  // ERROR: data is borrowed
46println!("{}", first);
47 
48// BETTER: scope the borrow
49let mut data = vec![1, 2, 3];
50let first = data[0];  // copy the value
51data.push(4);  // OK
52println!("{}", first);
53```
54 
55---
56 
57## Error Handling Anti-Patterns
58 
59### 4. Unwrap Everywhere
60 
61```rust
62// ANTI-PATTERN: crashes on error
63fn process_file(path: &str) {
64    let content = std::fs::read_to_string(path).unwrap();
65    let config: Config = toml::from_str(&content).unwrap();
66}
67 
68// BETTER: propagate errors
69fn process_file(path: &str) -> Result<Config, Error> {
70    let content = std::fs::read_to_string(path)?;
71    let config: Config = toml::from_str(&content)?;
72    Ok(config)
73}
74```
75 
76### 5. Ignoring Errors
77 
78```rust
79// ANTI-PATTERN: silent failure
80let _ = file.write_all(data);
81 
82// BETTER: handle or propagate
83file.write_all(data)?;
84// or at minimum, log the error
85if let Err(e) = file.write_all(data) {
86    eprintln!("Warning: failed to write: {}", e);
87}
88```
89 
90### 6. Panic in Library Code
91 
92```rust
93// ANTI-PATTERN: library panics
94pub fn parse(input: &str) -> Data {
95    if input.is_empty() {
96        panic!("input cannot be empty");
97    }
98    // ...
99}
100 
101// BETTER: return Result
102pub fn parse(input: &str) -> Result<Data, ParseError> {
103    if input.is_empty() {
104        return Err(ParseError::EmptyInput);
105    }
106    // ...
107}
108```
109 
110---
111 
112## String Anti-Patterns
113 
114### 7. String Instead of &str
115 
116```rust
117// ANTI-PATTERN: forces allocation
118fn greet(name: String) {
119    println!("Hello, {}", name);
120}
121 
122greet("world".to_string());  // allocation
123 
124// BETTER: accept &str
125fn greet(name: &str) {
126    println!("Hello, {}", name);
127}
128 
129greet("world");  // no allocation
130```
131 
132### 8. Format for Simple Concatenation
133 
134```rust
135// ANTI-PATTERN: format overhead
136let greeting = format!("{}{}", "Hello, ", name);
137 
138// BETTER for simple cases: push_str
139let mut greeting = String::from("Hello, ");
140greeting.push_str(name);
141 
142// Or use + for String + &str
143let greeting = String::from("Hello, ") + name;
144```
145 
146### 9. Repeated String Operations
147 
148```rust
149// ANTI-PATTERN: O(n²) allocations
150let mut result = String::new();
151for word in words {
152    result = result + word + " ";
153}
154 
155// BETTER: join
156let result = words.join(" ");
157 
158// Or with_capacity + push_str
159let mut result = String::with_capacity(total_len);
160for word in words {
161    result.push_str(word);
162    result.push(' ');
163}
164```
165 
166---
167 
168## Collection Anti-Patterns
169 
170### 10. Index Instead of Iterator
171 
172```rust
173// ANTI-PATTERN: bounds checking overhead
174for i in 0..vec.len() {
175    process(vec[i]);
176}
177 
178// BETTER: iterator
179for item in &vec {
180    process(item);
181}
182```
183 
184### 11. Collect Then Iterate
185 
186```rust
187// ANTI-PATTERN: unnecessary allocation
188let filtered: Vec<_> = items.iter().filter(|x| x.valid).collect();
189for item in filtered {
190    process(item);
191}
192 
193// BETTER: chain iterators
194for item in items.iter().filter(|x| x.valid) {
195    process(item);
196}
197```
198 
199### 12. Wrong Collection Type
200 
201```rust
202// ANTI-PATTERN: Vec for frequent membership checks
203let allowed: Vec<&str> = vec!["a", "b", "c"];
204if allowed.contains(&input) { ... }  // O(n)
205 
206// BETTER: HashSet for membership
207use std::collections::HashSet;
208let allowed: HashSet<&str> = ["a", "b", "c"].into();
209if allowed.contains(input) { ... }  // O(1)
210```
211 
212---
213 
214## Concurrency Anti-Patterns
215 
216### 13. Mutex for Read-Heavy Data
217 
218```rust
219// ANTI-PATTERN: Mutex when mostly reading
220let data = Arc::new(Mutex::new(config));
221// All readers block each other
222 
223// BETTER: RwLock for read-heavy workloads
224let data = Arc::new(RwLock::new(config));
225// Multiple readers can proceed in parallel
226```
227 
228### 14. Holding Lock Across Await
229 
230```rust
231// ANTI-PATTERN: lock held across await
232async fn bad() {
233    let guard = mutex.lock().unwrap();
234    some_async_op().await;  // lock held!
235    use(guard);
236}
237 
238// BETTER: scope the lock
239async fn good() {
240    let value = {
241        let guard = mutex.lock().unwrap();
242        guard.clone()
243    };  // lock released
244    some_async_op().await;
245    use(value);
246}
247```
248 
249### 15. Blocking in Async
250 
251```rust
252// ANTI-PATTERN: blocking call in async
253async fn bad() {
254    std::thread::sleep(Duration::from_secs(1));  // blocks executor!
255}
256 
257// BETTER: async sleep
258async fn good() {
259    tokio::time::sleep(Duration::from_secs(1)).await;
260}
261 
262// For CPU work: spawn_blocking
263async fn compute() {
264    tokio::task::spawn_blocking(|| heavy_work()).await
265}
266```
267 
268---
269 
270## Type System Anti-Patterns
271 
272### 16. Stringly Typed
273 
274```rust
275// ANTI-PATTERN: strings for everything
276fn connect(host: &str, port: &str, timeout: &str) { ... }
277connect("8080", "localhost", "30");  // wrong order!
278 
279// BETTER: strong types
280struct Host(String);
281struct Port(u16);
282struct Timeout(Duration);
283 
284fn connect(host: Host, port: Port, timeout: Timeout) { ... }
285```
286 
287### 17. Boolean Parameters
288 
289```rust
290// ANTI-PATTERN: what does true mean?
291fn fetch(url: &str, use_cache: bool, validate_ssl: bool) { ... }
292fetch("https://...", true, false);  // unclear
293 
294// BETTER: builder or named parameters
295struct FetchOptions {
296    use_cache: bool,
297    validate_ssl: bool,
298}
299 
300fn fetch(url: &str, options: FetchOptions) { ... }
301fetch("https://...", FetchOptions {
302    use_cache: true,
303    validate_ssl: false,
304});
305```
306 
307### 18. Option<Option<T>>
308 
309```rust
310// ANTI-PATTERN: nested Option
311fn find(id: u32) -> Option<Option<User>> { ... }
312// What does None vs Some(None) mean?
313 
314// BETTER: use Result or custom enum
315enum FindResult {
316    Found(User),
317    NotFound,
318    Error(String),
319}
320```
321 
322---
323 
324## API Design Anti-Patterns
325 
326### 19. Taking Ownership Unnecessarily
327 
328```rust
329// ANTI-PATTERN: takes ownership but doesn't need it
330fn validate(config: Config) -> bool {
331    config.timeout > 0 && config.retries >= 0
332}
333 
334// BETTER: borrow
335fn validate(config: &Config) -> bool {
336    config.timeout > 0 && config.retries >= 0
337}
338```
339 
340### 20. Returning References to Temporaries
341 
342```rust
343// ANTI-PATTERN: impossible lifetime
344fn get_default() -> &str {
345    let s = String::from("default");
346    &s  // ERROR: s is dropped
347}
348 
349// BETTER: return owned
350fn get_default() -> String {
351    String::from("default")
352}
353 
354// Or return static
355fn get_default() -> &'static str {
356    "default"
357}
358```
359 
360### 21. Overly Generic Functions
361 
362```rust
363// ANTI-PATTERN: complex generics for simple function
364fn process<T, U, V>(input: T) -> V
365where
366    T: Into<U>,
367    U: AsRef<str> + Clone,
368    V: From<String>,
369{ ... }
370 
371// BETTER: concrete types if generics not needed
372fn process(input: &str) -> String { ... }
373```
374 
375---
376 
377## Macro Anti-Patterns
378 
379### 22. Macro When Function Works
380 
381```rust
382// ANTI-PATTERN: macro for simple operation
383macro_rules! add {
384    ($a:expr, $b:expr) => { $a + $b };
385}
386 
387// BETTER: just use a function
388fn add(a: i32, b: i32) -> i32 { a + b }
389```
390 
391### 23. Complex Macro Without Tests
392 
393```rust
394// ANTI-PATTERN: complex macro with no tests
395macro_rules! define_api {
396    // ... 100 lines of macro code ...
397}
398 
399// BETTER: test macro outputs
400#[test]
401fn test_macro_expansion() {
402    // Use cargo-expand or trybuild
403}
404```
405 
406---
407 
408## Quick Reference
409 
410| Anti-Pattern | Better Alternative |
411|--------------|-------------------|
412| Clone everywhere | Borrow when possible |
413| Unwrap everywhere | Propagate with `?` |
414| `String` parameters | `&str` parameters |
415| Index loops | Iterator loops |
416| Collect then process | Chain iterators |
417| Mutex for reads | RwLock for read-heavy |
418| Lock across await | Scope the lock |
419| Blocking in async | spawn_blocking |
420| Stringly typed | Strong types |
421| Boolean params | Builders or enums |
422