Rust Clone Optimization

Overview

Remove unnecessary

.clone()

When to Use

• Asked to "remove clones" or "optimize memory"
• Reviewing Rust code for efficiency
• Seeing many

  .clone()

  calls in hot paths

When NOT to use:

• Arc::clone()

  /

  Rc::clone()

  - these are cheap, intentional
• Cold paths with small data - optimization not worth complexity
• Prototyping phase - correctness before performance

Analysis Hierarchy

Try techniques in this order. Stop at the first that works.

1. REORDER    → Move usage before the value is needed elsewhere
2. BORROW     → Pass &T or &str instead of owned
3. COW        → Cow<'_, str> for "sometimes owned"
4. STRUCTURAL → Change struct to hold references (last resort)

Never jump to step 4 before exhausting 1-3.

Quick Reference

state.modal = ...

login_state

.map(|x| x.field.clone())

&str

from_entry(entry, &name)

from_entry(entry, name.clone())

Cow<str>

name: Cow<'a, str>

let s = x.clone(); for _ in 0..n { use(&s) }

Technique 1: Reorder

Before:

let username = login_state.username.clone();
let password = login_state.password.clone();
state.modal = Modal::LoginPending;  // Invalidates login_state
api.send(ApiCommand::Login { username, password });

After:

// Send BEFORE changing modal - no clone needed
let cmd = ApiCommand::Login {
    username: login_state.username.clone(),  // Still need if Login takes owned
    password: login_state.password.clone(),
};
state.modal = Modal::LoginPending;
api.send(cmd);

Check: Does

ApiCommand::Login

String

&str

Technique 2: Borrow

Before:

fn process(name: String) { println!("{}", name); }
let task_name = task.name.clone();
process(task_name);

After:

fn process(name: &str) { println!("{}", name); }  // Accept reference
process(&task.name);  // No clone

When to use: Function only reads the value, doesn't store it.

Technique 3: Cow

Before:

struct Form {
    name: String,  // Always owned
}
// Must clone even for borrowed data
form.name = borrowed_str.to_string();

After:

use std::borrow::Cow;

struct Form<'a> {
    name: Cow<'a, str>,  // Borrowed OR owned
}
// No clone for borrowed
form.name = Cow::Borrowed(borrowed_str);
// Clone only when needed
form.name = Cow::Owned(compute_name());

When to use: Struct sometimes gets owned data, sometimes borrowed. Adds lifetime parameter.

Technique 4: Structural (Last Resort)

Change struct to hold references:

// Before: owns data
struct EntryForm { task_name: String }

// After: borrows data
struct EntryForm<'a> { task_name: &'a str }

Costs:

• Adds lifetime parameters throughout
• May require significant refactoring
• Can complicate APIs

Only use when: Hot path with large data AND techniques 1-3 don't apply.

Common Mistakes

std::mem::replace

Audit Process

1. Find clones:

   rg '\.clone\(\)'

   in target directory
2. Categorize each:
   • Arc/Rc → Skip (intentional)
   • Hot path → Prioritize
   • Cold path → Low priority
3. For each hot-path clone:
   • Can I reorder? → Do it
   • Can caller accept

     &T

     ? → Change signature
   • Need "sometimes owned"? → Use

     Cow

   • None work? → Consider if optimization is worth structural change
4. Verify:

   cargo test

   after each change

Checklist

• Identified Arc/Rc clones (skip these)
• Prioritized by hot path vs cold path
• Tried reordering before other techniques
• Checked if callers can accept references
• Only used Cow/structural changes when simpler options failed
• Ran tests after changes
• Kept changes minimal - no over-engineering