ownership-not-clone

Ownership, Not Clone

The borrow checker is a map of where ownership is being fudged, not an obstacle to route around. This skill decides who holds a value and for how long.

The rule

Every clone must be explainable in one sentence that is not "the borrow checker complained." A clone that buys a real thing — a value that must outlive the borrow — is fine; one that only silences an error is a deferred design decision.

Read the error, not the workaround

E0502 (a mutable borrow while an immutable one is still live) and E0499 (two mutable borrows of the same place) name a lifetime conflict; the fix is in the structure the error describes, not in the clone that silences it:

// No clone: `first` is Copy, so the borrow ends at the let.
let first = items[0];
for _ in 0..n {
    items.push(first);
}

Borrow splitting

The borrow checker tracks a whole value through method calls, but fields individually through direct field access. A &mut self method that also needs self.other_field is the classic false conflict — destructure once:

// The two fields are separate lets and borrow independently.
impl Server {
    fn handle(&mut self) {
        let Self { connections, log, .. } = self;
        for conn in connections.iter_mut() {
            log.record(conn.id());
        }
    }
}

split_at_mut hands back two disjoint &mut halves of one slice; when destructuring is not enough, extract a free function that takes the two fields.

Take the cheapest thing that works, in argument position

&str over &String, &[T] over &Vec<T>, impl AsRef<Path> over a PathBuf for a path a function only reads. A signature that takes String when it only reads forces every caller into a clone — the bug is in the signature.

// Forces a clone at every call site that holds a &str.
fn log_message(message: String) { ... }

// Reads only — callers pass a reference and copy nothing.
fn log_message(message: &str) { ... }