3.2 KiB
Clone to satisfy the borrow checker
Description
The borrow checker prevents Rust users from developing otherwise unsafe code by ensuring that either: only one mutable reference exists, or potentially many but all immutable references exist. If the code written does not hold true to these conditions, this anti-pattern arises when the developer resolves the compiler error by cloning the variable.
Example
// define any variable
let mut x = 5;
// Borrow `x` -- but clone it first
let y = &mut (x.clone());
// perform some action on the borrow to prevent rust from optimizing this
//out of existence
*y += 1;
// without the x.clone() two lines prior, this line would fail on compile as
// x has been borrowed
// thanks to x.clone(), x was never borrowed, and this line will run.
println!("{}", x);
Motivation
It is tempting, particularly for beginners, to use this pattern to resolve
confusing issues with the borrow checker. However, there are serious
consequences. Using .clone() causes a copy of the data to be made. Any changes
between the two are not synchronized -- as if two completely separate variables
exist.
There are special cases -- Rc<T> is designed to handle clones intelligently.
It internally manages exactly one copy of the data, and cloning it will only
clone the reference.
There is also Arc<T> which provides shared ownership of a value of type T
that is allocated in the heap. Invoking .clone() on Arc produces a new Arc
instance, which points to the same allocation on the heap as the source Arc,
while increasing a reference count.
In general, clones should be deliberate, with full understanding of the consequences. If a clone is used to make a borrow checker error disappear, that's a good indication this anti-pattern may be in use.
Even though .clone() is an indication of a bad pattern, sometimes
it is fine to write inefficient code, in cases such as when:
- the developer is still new to ownership
- the code doesn't have great speed or memory constraints (like hackathon projects or prototypes)
- satisfying the borrow checker is really complicated and you prefer to optimize readability over performance
If an unnecessary clone is suspected, The Rust Book's chapter on Ownership should be understood fully before assessing whether the clone is required or not.
Also be sure to always run cargo clippy in your project, which will detect some
cases in which .clone() is not necessary, like 1,
2,
3 or 4.