How to Use the Cow (Clone on Write) Pattern Effectively

Use the .clone() method to create an independent copy of a value when you need to retain ownership of the original while passing a copy to another scope. This is essential for types like String that do not implement the Copy trait.

let s1 = String::from("hello");
let s2 = s1.clone();

println!("s1 = {s1}, s2 = {s2}");

For generic functions, constrain your type parameters with the Clone trait in a where clause to ensure the compiler knows how to duplicate the data.

fn some_function<T, U>(t: &T, u: &U) -> i32
where
    T: Clone,
    U: Clone,
{
    let t_copy = t.clone();
    let u_copy = u.clone();
    0
}

When parsing command-line arguments into a struct, call .clone() on the String values extracted from the args vector to move ownership into the struct fields.

struct Config {
    query: String,
    file_path: String,
}

impl Config {
    fn new(args: &[String]) -> Config {
        let query = args.get(1).expect("missing query argument").clone();
        let file_path = args.get(2).expect("missing file path argument").clone();
        Config { query, file_path }
    }
}

fn main() {
    let args = vec![
        String::from("program_name"),
        String::from("search_query"),
        String::from("input.txt"),
    ];
    let config = Config::new(&args);
    println!("Config: query={}, file={}", config.query, config.file_path);
}

The Clone pattern is like making a photocopy of a document so you can give one to a colleague while keeping the original for yourself. In Rust, you use this when you need two separate, independent versions of data that would otherwise be moved or consumed. It prevents errors where the original data disappears after being passed to a function.